diff --git a/ijs.tree b/ijs.tree index 073d9092d..fad94e342 100644 --- a/ijs.tree +++ b/ijs.tree @@ -406,6 +406,16 @@ + + + + + + + + + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin.md new file mode 100644 index 000000000..461e19c36 --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin.md @@ -0,0 +1,253 @@ + + +# IntelliJ Platform Gradle Plugin 2.x (EAP) + +IntelliJ Platform Gradle Plugin user and migration guide. + + + +**Current Release**: %intellij-platform-gradle-plugin-version% (Early Access Preview) + +**GitHub**: [Releases & Changelog](https://github.com/JetBrains/gradle-intellij-plugin/releases), [Issue Tracker](https://github.com/JetBrains/gradle-intellij-plugin/issues) + +**Slack**: [#intellij-platform-gradle-plugin](https://jetbrains-platform.slack.com/archives/C05C80200LS) on the [JetBrains Platform Slack](https://plugins.jetbrains.com/slack/) + + + +The _IntelliJ Platform Gradle Plugin 2.x_ is a plugin for the Gradle build system to help configure your environment for building, testing, verifying, and publishing plugins for IntelliJ-based IDEs. + +It is going to replace the current _[](tools_gradle_intellij_plugin.md) (1.x)_ in the future. + +> See [](tools_intellij_platform_gradle_plugin_migration.md) for FAQ. +> + + + +> IntelliJ Platform Gradle Plugin 2.x is currently in **Early Access Preview** and may not support all features and project setups yet (see also [](tools_intellij_platform_gradle_plugin.md#requirements)). +> Please report bugs or problems in the GitHub issue tracker or Slack channel (see [here](tools_intellij_platform_gradle_plugin.md#tldr)). +> +> Any documentation issues should be reported using the feedback form on the bottom of this page. +> Please leave your email in case we need more details. +> +> Thanks a lot in advance for your feedback! +> +{title="Early Access Status" style="warning"} + + + +## Requirements + +The following platforms and environments are supported: + +- IntelliJ Platform: 2022.3 and later +- Java Runtime: 17 and later +- Gradle: 8.1 and later + +## Usage + +> Please note that the plugin has a new ID `org.jetbrain.intellij.platform`. +> +{style="note"} + +To use the current Early Access Preview snapshot versions, add the following to your settings.gradle.kts file: + +```kotlin +pluginManagement { + repositories { + maven("https://oss.sonatype.org/content/repositories/snapshots/") + gradlePluginPortal() + } +} +``` + +In the build.gradle.kts file, replace the existing reference to the [](tools_gradle_intellij_plugin.md) plugin (`org.jetbrains.intellij`) with: + +```kotlin +plugins { + id("org.jetbrains.intellij.platform") version "%intellij-platform-gradle-plugin-version%" +} +``` + +### Subplugins + +The plugin was split into subplugins that can be applied separately. +This allows for applying only a subset of features, e.g. when you only use an IntelliJ Platform SDK dependency without creating any tasks. + +#### org.jetbrains.intellij.platform +{#plugin.platform} + +This plugin applies all project-level plugins, which brings the fully-flagged tooling for plugin development for IntelliJ-based IDEs. + +It includes [](#plugin.core) and [](#plugin.tasks) subplugins. + +#### org.jetbrains.intellij.platform.core +{#plugin.core} + +The base plugin sets up all the custom configurations and transforms needed to manage the IntelliJ Platform SDK, JetBrains Runtime, CLI tools, and other plugins when they're added as dependencies. + +#### org.jetbrains.intellij.platform.tasks +{#plugin.tasks} + +Tasks plugin registers and preconfigures all tasks introduced by the IntelliJ Platform Gradle Plugin. +It can be omitted when referring to any IntelliJ Platform SDK dependencies without invoking tasks on project submodules. + +#### org.jetbrains.intellij.platform.settings +{#plugin.settings} + +If you define repositories within the settings.gradle.kts using the `dependencyResolutionManagement` Gradle, make sure to include the Settings plugin in your settings.gradle.kts. + +## Configuration + +> Auto-completion, Quick Documentation, and other code insight features are available for many extension functions and properties. +> +{title="Exploring Configuration Options"} + +### Setting Up Repositories +{#configuration.repositories} + +All IntelliJ Platform SDK artifacts are available via IntelliJ Maven repositories (see [](intellij_artifacts.md)), which exist in three variants: + +- releases +- snapshots +- nightly (only selected artifacts) + + + +**Example #2:** + +Build a plugin against a release version of the IntelliJ Platform with dependency on a plugin from the JetBrains Marketplace: + +```kotlin +repositories { + mavenCentral() + + intellijPlatform { + releases() + marketplace() + } +} +``` + +See [](tools_intellij_platform_gradle_plugin_repositories_extension.md) on how to configure additional repositories. + +#### Dependency Resolution Management +{#configuration.dependencyResolutionManagement} + +To access the IntelliJ Platform Gradle Plugin within the settings.gradle.kts to use with `dependencyResolutionManagement`, add: + +```kotlin +import org.jetbrains.intellij.platform.gradle.extensions.intellijPlatform + +plugins { + id("org.jetbrains.intellij.platform.settings") version "%intellij-platform-gradle-plugin-version%" +} + +dependencyResolutionManagement { + repositoriesMode = RepositoriesMode.FAIL_ON_PROJECT_REPOS + + repositories { + mavenCentral() + + intellijPlatform { + defaultRepositories() + } + } +} +``` + +#### Cache Redirector +{#configuration.cacheRedirector} + +Some repositories, by default, point to JetBrains Cache Redirector to provide better resources resolution. +However, it is possible to use the direct repository URL, if available. + +To switch off the default usage of JetBrains Cache Redirector, see the [](tools_intellij_platform_gradle_plugin_build_features.md#useCacheRedirector) build feature. + +### Setting Up IntelliJ Platform + +Dependencies and [repositories](#configuration.repositories) are handled using explicit entries within `dependencies {}` and `repositories {}` blocks in build.gradle.kts file. + +A minimum configuration for targeting IntelliJ IDEA Community 2023.3: + +```kotlin +repositories { + mavenCentral() + + intellijPlatform { + defaultRepositories() + } +} + +dependencies { + intellijPlatform { + intellijIdeaCommunity("2023.3") + } +} +``` + +The `intellijIdeaCommunity` in the previous sample is one of the extension functions available for adding IntelliJ Platform dependencies to the project. +See [](tools_intellij_platform_gradle_plugin_dependencies_extension.md) on how to target other IDEs. + +#### Parametrize IntelliJ Platform Dependency +{id="dependenciesParametrizePlatform"} + +As a fallback, `intellijPlatform` extension can be used to allow dynamic configuration of the target platform, e.g., via gradle.properties: + +``` +platformType = IC +platformVersion = 2023.3 +``` + +The above Gradle properties can be referenced in the build.gradle.kts file with: + +```kotlin +dependencies { + intellijPlatform { + val type = providers.gradleProperty("platformType") + val version = providers.gradleProperty("platformVersion") + + create(type, version) + } +} +``` + +The `intellijPlatform` helper accepts also the [`IntelliJPlatformType`](tools_intellij_platform_gradle_plugin_types.md#IntelliJPlatformType) type: + +```kotlin +import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType + +dependencies { + intellijPlatform { + val version = providers.gradleProperty("platformVersion") + + create(IntelliJPlatformType.IntellijIdeaUltimate, version) + } +} +``` + +#### Local IntelliJ Platform IDE Instance +{id="dependenciesLocalPlatform"} + +It is possible to refer to the locally available IntelliJ-based IDE using the `local` helper function: + +```kotlin +repositories { + intellijPlatform { + localPlatformArtifacts() + } +} + +dependencies { + intellijPlatform { + local("/Users/hsz/Applications/IntelliJ IDEA Ultimate.app") + } +} +``` + +Note that the `localPlatformArtifacts()` entry needs to be added to the `repositories {}` block as all local dependencies (local IDE, bundled plugins, etc.) rely on the Ivy repositories. + +### Setting Up Plugin Dependencies + +TODO + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_build_features.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_build_features.md new file mode 100644 index 000000000..452debe0f --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_build_features.md @@ -0,0 +1,97 @@ + + +# Build Features + +IntelliJ Platform Gradle Plugin build features. + + + +The IntelliJ Platform Gradle Plugin exposes a number of build features to control some of the low-level Gradle plugin behaviors. +To enable or disable a particular feature, add a Project property to the gradle.properties file with the following pattern: + +``` +org.jetbrains.intellij.buildFeature.= +``` + +E.g., to disable the [](#selfUpdateCheck) feature, add this line: + +``` +org.jetbrains.intellij.platform.buildFeature.selfUpdateCheck=false +``` + + +## noSearchableOptionsWarning +{#noSearchableOptionsWarning} + +When the [](tools_intellij_platform_gradle_plugin_tasks.md#buildSearchableOptions) doesn't produce any results, e.g., when the plugin doesn't implement any [Settings](settings.md), a warning is shown to suggest disabling it for better performance with [](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-buildSearchableOptions). + +{style="narrow"} +Default value +: `true` + +Example +: +``` +org.jetbrains.intellij.buildFeature.buildSearchableOptions=false +``` + + +## paidPluginSearchableOptionsWarning +{#paidPluginSearchableOptionsWarning} + +Due to IDE limitations, it is impossible to run the IDE in headless mode to collect searchable options for a paid plugin. +As paid plugins require providing a valid license and presenting a UI dialog, it is impossible to handle such a case, and the task will fail. +This feature flag displays the given warning when the task is run by a paid plugin. + +{style="narrow"} +Default value +: `true` + +Example +: +``` +org.jetbrains.intellij.platform.buildFeature.paidPluginSearchableOptionsWarning=false +``` + + +## selfUpdateCheck +{#selfUpdateCheck} + +Checks whether the currently used IntelliJ Platform Gradle Plugin is outdated and if a new release is available. +The plugin performs an update check on every run asking the GitHub Releases page for the redirection URL +to the latest version with `HEAD` HTTP request: [](https://github.com/jetbrains/gradle-intellij-plugin/releases/latest). + +If the current version is outdated, the plugin will emit a warning with its current and the latest version. + +Feature respects the Gradle [`--offline`](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_execution_options) mode. + +> It is strongly suggested to always use the latest available version. Older plugin versions may also not fully support the latest IDE releases. + +{style="narrow"} +Default value +: `true` + +Example +: +``` +org.jetbrains.intellij.platform.buildFeature.selfUpdateCheck=false +``` + + +## useCacheRedirector +{#useCacheRedirector} + +By default, JetBrains Cache Redirector is used when resolving Maven repositories or any resources used by the IntelliJ Platform Gradle Plugin. +Due to limitations, sometimes it is desired to limit the list of remote endpoints accessed by Gradle. + +It is possible to refer to the direct location (whenever it is possible) by switching off JetBrains Cache Redirector globally. + +{style="narrow"} +Default value +: `true` + +Example +: +``` +org.jetbrains.intellij.platform.buildFeature.useCacheRedirector=false +``` diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_dependencies_extension.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_dependencies_extension.md new file mode 100644 index 000000000..76af32bda --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_dependencies_extension.md @@ -0,0 +1,118 @@ + + +# Dependencies Extension + +IntelliJ Platform Gradle Plugin dependencies extension. + + + +Extension class for managing IntelliJ Platform dependencies in a Gradle build script applied to the `DependencyHandler`. + +This class provides methods for adding dependencies to different IntelliJ Platform products and managing local dependencies. + +It also includes methods for adding IntelliJ Platform plugins, IntelliJ Platform bundled plugins, JetBrains Runtime, as well as IntelliJ Plugin Verifier and Marketplace ZIP Signer tools. + +> Corresponding required repositories must be defined in `repositories {}` section, see [](tools_intellij_platform_gradle_plugin_repositories_extension.md). +> +{style="note"} + +**Example:** + +- setup Maven Central and [`defaultRepositories()`](tools_intellij_platform_gradle_plugin_repositories_extension.md#default-repositories) +- target IntelliJ IDEA Community %ijPlatform% +- add dependency on bundled Java plugin +- add IntelliJ Plugin Verifier and Marketplace ZIP Signer CLI tools + +```kotlin +repositories { + + mavenCentral() + + intellijPlatform { + defaultRepositories() + } +} + +dependencies { + + intellijPlatform { + intellijIdeaCommunity("%ijPlatform%") + + bundledPlugin("com.intellij.java") + + pluginVerifier() + zipSigner() + } + + // other dependencies, e.g., 3rd-party libraries +} +``` + +> Just one IntelliJ Platform dependency can be added to the project at a time. +> +{style="warning"} + +## Default Target Platforms + +See [](#custom-target-platforms) for non-default targets. + +| Function | Description | +|----------------------------------|------------------------------------------------------------------| +| `androidStudio(version)` | Adds a dependency on [Android Studio](android_studio.md). | +| `clion(version)` | Adds a dependency on [CLion](clion.md). | +| `fleetBackend(version)` | Adds a dependency on Fleet Backend. | +| `gateway(version)` | Adds a dependency on Gateway. | +| `goland(version)` | Adds a dependency on [GoLand](goland.md). | +| `intellijIdeaCommunity(version)` | Adds a dependency on [IntelliJ IDEA Community](idea.md). | +| `intellijIdeaUltimate(version)` | Adds a dependency on [IntelliJ IDEA Ultimate](idea_ultimate.md). | +| `phpstorm(version)` | Adds a dependency on [PhpStorm](phpstorm.md). | +| `pycharmCommunity(version)` | Adds a dependency on [PyCharm Community](pycharm.md). | +| `pycharmProfessional(version)` | Adds a dependency on [PyCharm Professional](pycharm.md). | +| `rider(version)` | Adds a dependency on [Rider](rider.md). | +| `rustRover(version)` | Adds a dependency on Rust Rover. | +| `writerside(version)` | Adds a dependency on Writerside. | + +## Custom Target Platforms + +| Function | Description | +|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------------| +| `create(type, version)` | Adds a configurable dependency on the IntelliJ Platform. See [](tools_intellij_platform_gradle_plugin.md#dependenciesParametrizePlatform). | +| `local(localPath)` | Adds a dependency on a local IntelliJ Platform instance. See [](tools_intellij_platform_gradle_plugin.md#dependenciesLocalPlatform). | + +See also: + +- [Types: `IntelliJPlatformType`](tools_intellij_platform_gradle_plugin_types.md#IntelliJPlatformType) + +## Plugins + +| Function | Description | +|--------------------------------|------------------------------------------------------------------------------------------------------------------------------| +| `plugin(id, version, channel)` | Adds a dependency on a plugin for IntelliJ Platform. | +| `plugin(notation)` | Adds a dependency on a plugin for IntelliJ Platform using a string notation (`pluginId:version`, `pluginId:version@channel`) | +| `plugins(notations)` | Adds dependencies on plugins for IntelliJ Platform using a string notation (`pluginId:version`, `pluginId:version@channel`) | +| `bundledPlugin(id)` | Adds a dependency on a bundled IntelliJ Platform plugin. | +| `bundledPlugins(ids)` | Adds dependencies on bundled IntelliJ Platform plugins. | + +See also: + +- [](plugin_dependencies.md) + +## Tools + +| Function | Description | +|---------------------------|-------------------------------------------------------------------------------------| +| `pluginVerifier(version)` | Adds a dependency on [IntelliJ Plugin Verifier](verifying_plugin_compatibility.md). | +| `zipSigner(version)` | Adds a dependency on [Marketplace ZIP Signer](plugin_signing.md). | + +See also: + +- [](verifying_plugin_compatibility.md), [Tasks: `verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) +- [](plugin_signing.md), [Tasks: `signPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin) + +## Java Runtime + +| Function | Description | +|-----------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------| +|

`jetbrainsRuntime(version, variant, architecture)`

`jetbrainsRuntime(explicitVersion)`

| Adds a dependency on [JetBrains Runtime](ide_development_instance.md#using-a-jetbrains-runtime-for-the-development-instance). | + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_extension.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_extension.md new file mode 100644 index 000000000..270f9ea00 --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_extension.md @@ -0,0 +1,1033 @@ + + +# IntelliJ Platform Extension + +IntelliJ Platform Gradle Plugin extension. + + + +The _IntelliJ Platform Gradle Plugin_ introduces a top-level `intellijPlatform` extension. +It consists of sections dedicated to the general Gradle plugin configuration, plugin.xml definition, publishing, signing, and verifying of the output plugin for IntelliJ-based IDEs. + + +## IntelliJ Platform +{#intellijPlatform} + +After the IntelliJ Platform Gradle Plugin is [applied](tools_intellij_platform_gradle_plugin.md#usage), the `intellijPlatform` extension can be used to configure the plugin and common settings of the provided tasks. + +**Example:** + +```kotlin +intellijPlatform { + buildSearchableOptions = true + instrumentCode = true + sandboxContainer = "..." + + pluginConfiguration { + // ... + } + publishing { + // ... + } + signing { + // ... + } + verifyPlugin { + // ... + } +} +``` + + +### buildSearchableOptions +{#intellijPlatform-buildSearchableOptions} + +Builds an index of UI components (searchable options) for the plugin. +Controls the execution of the [`buildSearchableOptions`](tools_intellij_platform_gradle_plugin_tasks.md#buildSearchableOptions) task. + +{style="narrow"} +Type +: `Property` + +Default value +: `true` + +See also: +- [Build Features: `noSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#noSearchableOptionsWarning) + + +### instrumentCode +{#intellijPlatform-instrumentCode} + +> Not implemented. +> +{style="warning"} + +Enables the compiled classes instrumentation. +The compiled code will be enhanced with: +- nullability assertions +- post-processing of forms created by IntelliJ GUI Designer + +Controls the execution of the [`instrumentCode`](tools_intellij_platform_gradle_plugin_tasks.md#instrumentCode) task. + +{style="narrow"} +Type +: `Property` + +Default value +: `true` + + +### productInfo +{#intellijPlatform-productInfo} + +Provides read access for the [`ProductInfo`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo) object associated with the IntelliJ Platform dependency configured for the current project. + +{style="narrow"} +Type +: [`Property`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo) + +Default value +: [`ProductInfo`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo) for the current IntelliJ Platform + + +### sandboxContainer +{#intellijPlatform-sandboxContainer} + +The path to the sandbox container where tests and IDE instances read and write data. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/[Sandbox.CONTAINER] + +See also: +- [Tasks: `prepareSandbox`](tools_intellij_platform_gradle_plugin_tasks.md#prepareSandbox) +- [Task Awares: `SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware) + + +## Plugin Configuration +{#intellijPlatform-pluginConfiguration} + +Configures the plugin definition and stores values in the `plugin.xml` file. +Data provided to the `intellijPlatform.pluginConfiguration {}` extension is passed to the [`patchPluginXml`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml) task, which augments the plugin.xml file with new values. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + pluginConfiguration { + id = "my-plugin-id" + name = "My Awesome Plugin" + version = "1.0.0" + description = "It's an awesome plugin!" + changeNotes = + """ + A descriptive release note... + """.trimIndent() + + productDescriptor { + // ... + } + ideaVersion { + // ... + } + vendor { + // ... + } + } +} +``` + +See also: +- [](#intellijPlatform-pluginConfiguration-productDescriptor) +- [](#intellijPlatform-pluginConfiguration-ideaVersion) +- [](#intellijPlatform-pluginConfiguration-vendor) + + +### id +{#intellijPlatform-pluginConfiguration-id} + +The plugin's unique identifier. +This should mirror the structure of fully qualified Java packages and must remain distinct from the IDs of existing plugins. +This ID is a technical descriptor used not only within the IDE, but also on [JetBrains Marketplace](https://plugins.jetbrains.com/). + +Please restrict input to characters, numbers, and `.`/`-`/`_` symbols, and aim for a concise length. + +The entered value will populate the `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.pluginId`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-pluginId) +- [Plugin Configuration File: `id`](plugin_configuration_file.md#idea-plugin__id) + + +### name +{#intellijPlatform-pluginConfiguration-name} + +The plugin's display name, visible to users (Title Case). + +The inputted value will be used to populate the `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.pluginName`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-pluginName) +- [Plugin Configuration File: `name`](plugin_configuration_file.md#idea-plugin__name) + + +### version +{#intellijPlatform-pluginConfiguration-version} + +The plugin version, presented in the Plugins settings dialog and on its JetBrains Marketplace page. + +For plugins uploaded to the JetBrains Marketplace, [semantic versioning](https://plugins.jetbrains.com/docs/marketplace/semver.html) must be adhered to. + +The specified value will be used as a `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.pluginVersion`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-pluginVersion) +- [Plugin Configuration File: `version`](plugin_configuration_file.md#idea-plugin__version) + + +### description +{#intellijPlatform-pluginConfiguration-description} + +The plugin description, which is presented on the JetBrains Marketplace plugin page and in the Plugins settings dialog. +Basic HTML elements such as text formatting, paragraphs, and lists are permitted. + +The description content is automatically enclosed in ``. + +The supplied value will populate the `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.pluginDescription`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-pluginDescription) +- [Plugin Configuration File: `description`](plugin_configuration_file.md#idea-plugin__description) + + +### changeNotes +{#intellijPlatform-pluginConfiguration-changeNotes} + +A concise summary of new features, bug fixes, and alterations provided in the latest plugin version. +These change notes will be displayed on the JetBrains Marketplace plugin page and in the Plugins settings dialog. +Basic HTML elements such as text formatting, paragraphs, and lists are permitted. + +The change notes content is automatically enclosed in ``. + +The inputted value will populate the `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.changeNotes`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-changeNotes) +- [Plugin Configuration File: `change-notes`](plugin_configuration_file.md#idea-plugin__change-notes) + + +## Product Descriptor +{#intellijPlatform-pluginConfiguration-productDescriptor} + +A part of the [](#intellijPlatform-pluginConfiguration) which describes the `product-descriptor` element. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + pluginConfiguration { + // ... + + productDescriptor { + code = "MY_CODE" + releaseDate = "20240217" + releaseVersion = "20241" + optional = false + } + } +} +``` + +See also: +- [How to add required parameters for paid plugins](https://plugins.jetbrains.com/docs/marketplace/add-required-parameters.html) + + +### code +{#intellijPlatform-pluginConfiguration-productDescriptor-code} + +The product code for the plugin, used in the JetBrains Sales System, needs to be pre-approved by JetBrains and must adhere to [specified requirements](https://plugins.jetbrains.com/docs/marketplace/obtain-a-product-code-from-jetbrains.html). + +The given value will be utilized as a `` element attribute. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.productDescriptorCode`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-productDescriptorCode) +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### releaseDate +{#intellijPlatform-pluginConfiguration-productDescriptor-releaseDate} + +The release date of the major version, formatted as `YYYYMMDD`. + +The supplied value will be used to populate the `` element attribute. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.productDescriptorReleaseDate`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-productDescriptorReleaseDate) +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### releaseVersion +{#intellijPlatform-pluginConfiguration-productDescriptor-releaseVersion} + +The major version, represented in a specific numerical format. + +The given value will be used as the `` element attribute. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.productDescriptorReleaseVersion`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-productDescriptorReleaseVersion) +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### optional +{#intellijPlatform-pluginConfiguration-productDescriptor-optional} + +The boolean value that indicates if the plugin is a [Freemium](https://plugins.jetbrains.com/docs/marketplace/freemium.html) plugin. + +The inputted value will be used for the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + +See also: +- [Tasks: `patchPluginXml.productDescriptorOptional`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-productDescriptorOptional) +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +## Idea Version +{#intellijPlatform-pluginConfiguration-ideaVersion} + +A part of the [](#intellijPlatform-pluginConfiguration) which describes the `` element. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + pluginConfiguration { + // ... + + ideaVersion { + sinceBuild = "241" + untilBuild = "241.*" + } + } +} +``` +See also: + +- [Plugin Configuration File: `idea-version`](plugin_configuration_file.md#idea-plugin__idea-version) +- [](build_number_ranges.md) + +### sinceBuild +{#intellijPlatform-pluginConfiguration-ideaVersion-sinceBuild} + +The earliest IDE version that is compatible with the plugin. + +The supplied value will be utilized as the `` element attribute. + +The default value is set to the `MAJOR.MINOR` version based on the currently selected IntelliJ Platform, like `233.12345`. + +{style="narrow"} +Type +: `Property` + +Default value +: `MAJOR.MINOR` + +See also: +- [Tasks: `patchPluginXml.sinceBuild`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-sinceBuild) + + +### untilBuild +{#intellijPlatform-pluginConfiguration-ideaVersion-untilBuild} + +The latest IDE version that is compatible with the plugin. +An undefined value signifies compatibility with all IDEs starting from the version mentioned in `since-build`, +including potential future builds that may cause compatibility issues. + +The given value will be assigned to the `` element attribute. + +The default value is set to the `MAJOR.*` version based on the currently selected IntelliJ Platform, such as `233.*`. + +The `until-build` attribute can be unset by setting `provider { null }` as a value. +Note that passing only `null` will make Gradle use a default value instead. + +{style="narrow"} +Type +: `Property` + +Default value +: `MAJOR.*` + +See also: +- [Tasks: `patchPluginXml.untilBuild`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-untilBuild) + + +## Vendor +{#intellijPlatform-pluginConfiguration-vendor} + +A part of the [](#intellijPlatform-pluginConfiguration) which describes the `` element. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + pluginConfiguration { + // ... + + vendor { + name = "JetBrains" + email = "hello@jetbrains.com" + url = "https://www.jetbrains.com" + } + } +} +``` + +See also: +- [Plugin Configuration File: `vendor`](plugin_configuration_file.md#idea-plugin__vendor) + +### name +{#intellijPlatform-pluginConfiguration-vendor-name} + +The name of the vendor or the organization ID (if created), as displayed in the Plugins settings dialog and on the JetBrains Marketplace plugin page. + +The supplied value will be used as the value for the `` element. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.vendorName`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-vendorName) + + +### email +{#intellijPlatform-pluginConfiguration-vendor-email} + +The email address of the vendor. + +The given value will be utilized as the `` element attribute. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.vendorEmail`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-vendorEmail) + + +### url +{#intellijPlatform-pluginConfiguration-vendor-url} + +The URL to the vendor's homepage. + +The supplied value will be assigned to the `` element attribute. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `patchPluginXml.vendorUrl`](tools_intellij_platform_gradle_plugin_tasks.md#patchPluginXml-vendorUrl) + + +## Publishing +{#intellijPlatform-publishing} + +Configures the publishing process of the plugin. +All values are passed to the [](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin) task. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + publishing { + host = "" + token = "7hR4nD0mT0k3n_8f2eG" + channels = listOf("default") + toolboxEnterprise = false + hidden = false + } +} +``` + + +### host +{#intellijPlatform-publishing-host} + +The hostname used for publishing the plugin. + +{style="narrow"} +Type +: `Property` + +Default value +: `"https://plugins.jetbrains.com"` + +See also: +- [Tasks: `publishPlugin.host`](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin-host) + + +### token +{#intellijPlatform-publishing-token} + +Authorization token. + +{style="narrow"} +Type +: `Property` + +Required +: yes + +See also: +- [Tasks: `publishPlugin.token`](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin-token) + + +### channels +{#intellijPlatform-publishing-channels} + +A list of channel names to upload plugin to. + +{style="narrow"} +Type +: `ListProperty` + +Default value: +: `listOf("default")` + +See also: +- [Tasks: `publishPlugin.channels`](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin-channels) + + +### toolboxEnterprise +{#intellijPlatform-publishing-toolboxEnterprise} + +Specify if the Toolbox Enterprise plugin repository service should be used. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + +See also: +- [Tasks: `publishPlugin.toolboxEnterprise`](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin-toolboxEnterprise) + + +### hidden +{#intellijPlatform-publishing-hidden} + +Publish the plugin update and mark it as hidden to prevent public release after approval. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + +See also: +- [Tasks: `publishPlugin.hidden`](tools_intellij_platform_gradle_plugin_tasks.md#publishPlugin-hidden) +- [Hidden release](https://plugins.jetbrains.com/docs/marketplace/hidden-plugin.html) + + +## Signing +{#intellijPlatform-signing} + +Plugin signing configuration. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + signing { + cliPath = file("/path/to/marketplace-zip-signer-cli.jar") + keyStore = file("/path/to/keyStore.ks") + keyStorePassword = "..." + keyStoreKeyAlias = "..." + keyStoreType = "..." + keyStoreProviderName = "..." + privateKey = "..." + privateKeyFile = file("/path/to/private.pem") + password = "..." + certificateChain = "..." + certificateChainFile = file("/path/to/chain.crt") + } +} +``` + +See also: +- [](plugin_signing.md) +- [Tasks: `signPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin) +- [Task Awares: `SigningAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SigningAware) +- [Marketplace ZIP Signer](https://github.com/JetBrains/marketplace-zip-signer) + + +### cliPath +{#intellijPlatform-signing-cliPath} + +A path to the local Marketplace ZIP Signer CLI tool to be used. + +{style="narrow"} +Type +: `RegularFileProperty` + +See also: +- [Task Awares: `SigningAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SigningAware) + + +### keyStore +{#intellijPlatform-signing-keyStore} + +KeyStore file path. +Refers to `ks` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.keyStore`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-keyStore) + + +### keyStorePassword +{#intellijPlatform-signing-keyStorePassword} + +KeyStore password. +Refers to `ks-pass` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.keyStorePassword`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-keyStorePassword) + + +### keyStoreKeyAlias +{#intellijPlatform-signing-keyStoreKeyAlias} + +KeyStore key alias. +Refers to `ks-key-alias` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.keyStoreKeyAlias`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-keyStoreKeyAlias) + + +### keyStoreType +{#intellijPlatform-signing-keyStoreType} + +KeyStore type. +Refers to `ks-type` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.keyStoreType`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-keyStoreType) + + +### keyStoreProviderName +{#intellijPlatform-signing-keyStoreProviderName} + +JCA KeyStore Provider name. +Refers to `ks-provider-name` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.keyStoreProviderName`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-keyStoreProviderName) + + +### privateKey +{#intellijPlatform-signing-privateKey} + +Encoded private key in the PEM format. +Refers to `key` CLI option. + +Takes precedence over the [](#intellijPlatform-signing-privateKeyFile) property. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.privateKey`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-privateKey) + + +### privateKeyFile +{#intellijPlatform-signing-privateKeyFile} + +A file with an encoded private key in the PEM format. +Refers to `key-file` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +See also: +- [Tasks: `signPlugin.privateKeyFile`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-privateKeyFile) + + +### password +{#intellijPlatform-signing-password} + +Password required to decrypt the private key. +Refers to `key-pass` CLI option. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.password`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-password) + + +### certificateChain +{#intellijPlatform-signing-certificateChain} + +A string containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert` CLI option. + +Takes precedence over the [](#intellijPlatform-signing-certificateChainFile) property. + +{style="narrow"} +Type +: `Property` + +See also: +- [Tasks: `signPlugin.certificateChain`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-certificateChain) + + +### certificateChainFile +{#intellijPlatform-signing-certificateChainFile} + +Path to the file containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert-file` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +See also: +- [Tasks: `signPlugin.certificateChainFile`](tools_intellij_platform_gradle_plugin_tasks.md#signPlugin-certificateChainFile) + + +## Verify Plugin +{#intellijPlatform-verifyPlugin} + +IntelliJ Plugin Verifier CLI tool configuration. + +**Example:** + +```kotlin +intellijPlatform { + // ... + + verifyPlugin { + cliPath = file("/path/to/plugin-verifier-cli.jar") + freeArgs = listOf("foo", "bar") + homeDirectory = file("/path/to/pluginVerifierHomeDirectory/") + downloadDirectory = file("/path/to/pluginVerifierHomeDirectory/ides/") + failureLevel = VerifyPluginTask.FailureLevel.ALL + verificationReportsDirectory = "build/reports/pluginVerifier" + verificationReportsFormats = VerifyPluginTask.VerificationReportsFormats.ALL + externalPrefixes = "com.example" + teamCityOutputFormat = false + subsystemsToCheck = VerifyPluginTask.Subsystems.ALL + ignoredProblemsFile = file("/path/to/ignoredProblems.txt") + + ides { + // ... + } + } +} +``` + +See also: +- [](verifying_plugin_compatibility.md) +- [Tasks: `verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) +- [Task Awares: `PluginVerifierAware`](tools_intellij_platform_gradle_plugin_task_awares.md#PluginVerifierAware) +- [](#intellijPlatform-verifyPlugin-ides) +- [IntelliJ Plugin Verifier CLI](https://github.com/JetBrains/intellij-plugin-verifier) + + +### cliPath +{#intellijPlatform-verifyPlugin-cliPath} + +A path to the local IntelliJ Plugin Verifier CLI tool to be used. + +{style="narrow"} +Type +: `RegularFileProperty` + +See also: +- [Task Awares: `PluginVerifierAware`](tools_intellij_platform_gradle_plugin_task_awares.md#PluginVerifierAware) + + +### downloadDirectory +{#intellijPlatform-verifyPlugin-downloadDirectory} + +The path to the directory where IDEs used for the verification will be downloaded. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [`homeDirectory`](#intellijPlatform-verifyPlugin-homeDirectory)/ides + + +### failureLevel +{#intellijPlatform-verifyPlugin-failureLevel} + +Defines the verification level at which the task should fail if any reported issue matches. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: [`FailureLevel.COMPATIBILITY_PROBLEMS`](tools_intellij_platform_gradle_plugin_types.md#FailureLevel) + +See also: +- [Tasks: `verifyPlugin.failureLevel`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-failureLevel) + + +### externalPrefixes +{#intellijPlatform-verifyPlugin-externalPrefixes} + +The list of class prefixes from the external libraries. +The Plugin Verifier will not report `No such class` for classes of these packages. + +{style="narrow"} +Type +: `ListProperty` + +See also: +- [Tasks: `verifyPlugin.externalPrefixes`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-externalPrefixes) + + +### freeArgs +{#intellijPlatform-verifyPlugin-freeArgs} + +The list of free arguments is passed directly to the IntelliJ Plugin Verifier CLI tool. + +They can be used in addition to the arguments that are provided by dedicated options. + +{style="narrow"} +Type +: `ListProperty` + +See also: +- [Tasks: `verifyPlugin.freeArgs`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-freeArgs) + + +### homeDirectory +{#intellijPlatform-verifyPlugin-homeDirectory} + +Retrieve the Plugin Verifier home directory used for storing downloaded IDEs. +Following home directory resolving method is taken directly from the Plugin Verifier to keep the compatibility. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: - Directory specified with `plugin.verifier.home.dir` system property + - Directory specified with `XDG_CACHE_HOME` environment variable + - ~/.cache/pluginVerifier + - [buildDirectory]/tmp/pluginVerifier + + +### ignoredProblemsFile +{#intellijPlatform-verifyPlugin-ignoredProblemsFile} + +A file that contains a list of problems that will be ignored in a report. + +{style="narrow"} +Type +: `RegularFileProperty` + +See also: +- [Tasks: `verifyPlugin.ignoredProblemsFile`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-ignoredProblemsFile) + + +### subsystemsToCheck +{#intellijPlatform-verifyPlugin-subsystemsToCheck} + +Which subsystems of the IDE should be checked. + +{style="narrow"} +Type +: `Subsystems` + +Default value +: [`Subsystems.ALL`](tools_intellij_platform_gradle_plugin_types.md#Subsystems) + +See also: +- [Tasks: `verifyPlugin.subsystemsToCheck`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-subsystemsToCheck) + + +### teamCityOutputFormat +{#intellijPlatform-verifyPlugin-teamCityOutputFormat} + +A flag that controls the output format. +If set to `true`, the TeamCity compatible output will be returned to stdout. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + +See also: +- [Tasks: `verifyPlugin.teamCityOutputFormat`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-teamCityOutputFormat) + + +### verificationReportsDirectory +{#intellijPlatform-verifyPlugin-verificationReportsDirectory} + +The path to the directory where verification reports will be saved. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/reports/pluginVerifier + +See also: +- [Tasks: `verifyPlugin.verificationReportsDirectory`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-verificationReportsDirectory) + + +### verificationReportsFormats +{#intellijPlatform-verifyPlugin-verificationReportsFormats} + +The output formats of the verification reports. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: [`VerificationReportsFormats.PLAIN`](tools_intellij_platform_gradle_plugin_types.md#VerificationReportsFormats), [`FailureVerificationReportsFormats`](tools_intellij_platform_gradle_plugin_types.md#VerificationReportsFormats) + +See also: +- [Tasks: `verifyPlugin.verificationReportsFormats`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-verificationReportsFormats) + + +## Verify Plugin IDEs +{#intellijPlatform-verifyPlugin-ides} + +The extension to define the IDEs to be used along with the IntelliJ Plugin Verifier CLI tool for the binary plugin verification. + +It provides a set of helpers which add relevant entries to the configuration, which later is used to resolve IntelliJ-based IDE binary releases. + +**Example:** + +```kotlin +import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType + +intellijPlatform { + // ... + + verifyPlugin { + // ... + + ides { + ide(IntelliJPlatformType.PhpStorm) + ide(IntelliJPlatformType.RustRover, "2023.3") + localIde(file("/path/to/ide/")) + recommended() + select { + types = listOf(IntelliJPlatformType.PhpStorm) + channels = listOf(ProductRelease.Channel.RELEASE) + sinceBuild = "232" + untilBuild = "241.*" + } + } + } +} +``` + +See also: +- [](verifying_plugin_compatibility.md) +- [Tasks: `verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) +- [Types: `IntelliJPlatformType`](tools_intellij_platform_gradle_plugin_types.md#IntelliJPlatformType) +- [Types: `ProductRelease.Channel`](tools_intellij_platform_gradle_plugin_types.md#ProductRelease-Channel) +- [Types: `ProductReleasesValueSource.FilterParameters`](tools_intellij_platform_gradle_plugin_types.md#ProductReleasesValueSource-FilterParameters) + +| Function | Description | +|-----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +|

`ide(type, version)`

`ide(definition)`

| Adds a dependency to a binary IDE release to be used for testing with the IntelliJ Plugin Verifier. | +| `localIde(localPath)` | Adds the local IDE to be used for testing with the IntelliJ Plugin Verifier. | +| `recommended()` | Retrieves matching IDEs using the default configuration based on the currently used IntelliJ Platform and applies them for IntelliJ Platform Verifier using the `ide` helper method. | +| `select(configure)` | Retrieves matching IDEs using custom [`ProductReleasesValueSource.FilterParameters`](tools_intellij_platform_gradle_plugin_types.md#ProductReleasesValueSource-FilterParameters) filter parameters. | + + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_migration.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_migration.md new file mode 100644 index 000000000..a83b8b5af --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_migration.md @@ -0,0 +1,58 @@ + + +# Migration Guide from Gradle IntelliJ Plugin + +IntelliJ Platform Gradle Plugin 2.x migration guide from Gradle IntelliJ Plugin 1.x + + + +## Plugin name change + +As the `2.x` branch brings significant breaking changes to the plugin, the name was changed from _Gradle IntelliJ Plugin_ to +_IntelliJ Platform Gradle Plugin_ as the old one was confused with the bundled Gradle support plugin in the IDE. +The plugin is published to the Gradle Plugin Portal with a new name as a new entry, and the old one is marked as deprecated. + +## Plugin ID change + +Plugin ID has changed from `org.jetbrains.intellij` to `org.jetbrains.intellij.platform`. +To apply it, use: + +```kotlin +plugins { + id("org.jetbrains.intellij.platform") +} +``` + +## Minimum Gradle version + +The minimum required Gradle version is now `8.0`, see [Gradle Installation](https://gradle.org/install/) guide on how to upgrade. +See also [](tools_intellij_platform_gradle_plugin.md#requirements). + +## `intellij` extension + +The `intellij {}` extension is no longer available and was replaced with `intellijPlatform {}`. +Note that the available properties differ, see [](tools_intellij_platform_gradle_plugin_extension.md) for details. + +## `setupDependencies` task + +To make the IntelliJ SDK dependency available in the IDE, the `setupDependencies` task was provided by Gradle IntelliJ Plugin 1.x. +This task is no longer required, but when switching from 1.x, Gradle may still want to execute it in the _afterSync_ phase. +To completely drop this approach, it is mandatory to remove its reference manually in the IDE. + + + +1. Open Gradle Tool Window +2. Right-click on the main module and select Tasks Activation +3. In the Tasks Activation modal window, find and remove the `setupDependencies` entry. + + + +## Unresolved 'idea-ext' Plugin + +Add an explicit dependency on [the plugin](https://github.com/JetBrains/gradle-idea-ext-plugin) in build.gradle.kts: + +```kotlin +plugins { + id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.7" +} +``` diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_repositories_extension.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_repositories_extension.md new file mode 100644 index 000000000..b057166d2 --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_repositories_extension.md @@ -0,0 +1,93 @@ + + +# Repositories Extension + +IntelliJ Platform Gradle Plugin repositories extension. + + + +This is an extension class for managing IntelliJ Platform repositories in a Gradle build script. +It's applied to the `RepositoryHandler`. + +Available in both `Project` scope and Gradle Settings for `DependencyResolutionManagement`. + +It provides methods to add: + +- IntelliJ Platform repositories (for releases, snapshots, and nightly builds) +- JetBrains Marketplace repository for fetching plugins +- JetBrains Runtime repository +- Android Studio and IntelliJ Platform binary release repositories (for IntelliJ Plugin Verifier) +- Ivy local repository (for correct access to local dependencies) + + + +> In most cases, simply using [`defaultRepositories()`](tools_intellij_platform_gradle_plugin_repositories_extension.md#default-repositories) repository will be sufficient. +> +{style="tip"} + +**Example:** + +Setup Maven Central and [`defaultRepositories()`](tools_intellij_platform_gradle_plugin_repositories_extension.md#default-repositories) repositories: + +```kotlin +repositories { + mavenCentral() + + intellijPlatform { + defaultRepositories() + } +} +``` + + + +## Default Repositories + +The default repository definition suitable for most plugins. + +| Function | Description | +|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------| +| `defaultRepositories()` | Applies a set of recommended repositories required for running the most common tasks provided by the IntelliJ Platform Gradle Plugin. | + +It includes: +- `localPlatformArtifacts()` — required to use plugins bundled with IntelliJ Platform or refer to the local IDE +- `releases()` and `snapshots()` — IntelliJ Platform releases channels +- `marketplace()` — JetBrains Marketplace plugins repository +- `binaryReleases()` — JetBrains IDEs releases required for running the IntelliJ Plugin Verifier + + +## IDE Releases + +| Function | Description | +|---------------|---------------------------------------------------------------------------------------------| +| `releases()` | Adds a repository for accessing IntelliJ Platform stable releases. | +| `snapshots()` | Adds a repository for accessing IntelliJ Platform snapshot releases. | +| `nightly()` | Adds a repository for accessing IntelliJ Platform nightly releases, not available publicly. | + +See also: +- [](intellij_artifacts.md) + +## Binary IDE Releases + +| Function | Description | +|---------------------------------|--------------------------------------------------------------------------------------------------------------| +| `binaryReleases()` | Adds a repository for accessing IntelliJ Platform IDE binary releases for use with IntelliJ Plugin Verifier. | +| `binaryReleasesAndroidStudio()` | Adds a repository for accessing Android Studio binary releases for use with IntelliJ Plugin Verifier. | + +See also: + +- [](verifying_plugin_compatibility.md) + +## Additional Repositories + +| Function | Description | +|----------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `localPlatformArtifacts()` | Certain dependencies, such as the [local IntelliJ Platform instance](tools_intellij_platform_gradle_plugin.md#dependenciesLocalPlatform) and bundled IDE plugins, need extra pre-processing before they can be correctly used by the IntelliJ Platform Gradle Plugin and loaded by Gradle. This pre-processing involves generating XML files that detail these specific artifacts. Once created, these XMLs are stored in a unique custom [Ivy](https://ant.apache.org/ivy/) repository directory. | +| `jetbrainsRuntime()` | Adds a repository for accessing [JetBrains Runtime](ide_development_instance.md#using-a-jetbrains-runtime-for-the-development-instance) releases. | +| `marketplace()` | Adds a repository for accessing plugins hosted on [JetBrains Marketplace](https://plugins.jetbrains.com). | + +See also: + +- [](plugin_dependencies.md) + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_task_awares.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_task_awares.md new file mode 100644 index 000000000..54661ea58 --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_task_awares.md @@ -0,0 +1,305 @@ + + +# Task Awares + +IntelliJ Platform Gradle Plugin task `*Aware` interfaces. + + + +The Task Awares is a set of interfaces that can be applied to custom Gradle tasks and, when registered using the dedicated register method, inject new features or properties with predefined values. + + +## CoroutinesJavaAgentAware +{#CoroutinesJavaAgentAware} + +[`CoroutinesJavaAgentAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/CoroutinesJavaAgentAware.kt) + +The interface provides the path to the Java Agent file for the Coroutines library required to enable coroutines debugging. + +Inherited also by [`RunnableIdeAware`](#RunnableIdeAware). + +### coroutinesJavaAgentFile +{#CoroutinesJavaAgentAware-coroutinesJavaAgentFile} + +The path to the coroutines Java Agent file. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`initializeIntellijPlatformPlugin.coroutinesJavaAgent`](tools_intellij_platform_gradle_plugin_tasks.md#initializeIntelliJPlatformPlugin-coroutinesJavaAgent) + + +## CustomIntelliJPlatformVersionAware +{#CustomIntelliJPlatformVersionAware} + +[`CustomIntelliJPlatformVersionAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/CustomIntelliJPlatformVersionAware.kt) + +By default, the project with the IntelliJ Platform Gradle Plugin applied required the presence of the IntelliJ Platform, referred to later by various tasks, configurations, and extensions. + +The custom IntelliJ Platform concept allows using another version, i.e., to run a guest IDE or tests against it. + +When applying this interface to the task, custom configurations to hold new dependencies defined by [`type`](#CustomIntelliJPlatformVersionAware-type) and [`version`](#CustomIntelliJPlatformVersionAware-version) (or [`localPath`](#CustomIntelliJPlatformVersionAware-localPath), if referring to the local IntelliJ Platform instance) are created, as well as a dedicated [`prepareSandbox`](tools_intellij_platform_gradle_plugin_tasks.md#prepareSandbox) task. + +Configurations, as well as the task preparing sandbox for running and testing the custom IntelliJ Platform (if required), have a random suffix applied to avoid collisions. + + +### type +{#CustomIntelliJPlatformVersionAware-type} + +An input property to configure the type of the custom IntelliJ Platform. + +By default, it refers to the IntelliJ Platform type used by the current project. + +{style="narrow"} +Type +: [`IntelliJPlatformType`](tools_intellij_platform_gradle_plugin_types.md#IntelliJPlatformType) + + +### version +{#CustomIntelliJPlatformVersionAware-version} + +An input property to configure the version of the custom IntelliJ Platform. + +By default, it refers to the IntelliJ Platform version used by the current project. + +{style="narrow"} +Type +: `Property` + + +### localPath +{#CustomIntelliJPlatformVersionAware-localPath} + +An input property to define the path to the local IntelliJ Platform instance to configure the version of the custom IntelliJ Platform. + +The local path precedes the IntelliJ Platform resolution using the [`type`](#CustomIntelliJPlatformVersionAware-type) and [`version`](#CustomIntelliJPlatformVersionAware-version) properties. + +{style="narrow"} +Type +: `DirectoryProperty` + + +## IntelliJPlatformVersionAware +{#IntelliJPlatformVersionAware} + +[`IntelliJPlatformVersionAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/IntelliJPlatformVersionAware.kt) + +This interface provides tasks a possibility for accessing information about the IntelliJ Platform currently used in the project. + +The [`intelliJPlatformConfiguration`](#IntelliJPlatformVersionAware-intelliJPlatformConfiguration) input property receives a dependency added to the `intellijPlatform` configuration, which eventually is resolved and lets to access the IntelliJ Platform details such as [`ProductInfo`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo) or the path to the IntelliJ Platform directory. + +It is required to have a dependency on the IntelliJ Platform added to the project with helpers available in [](tools_intellij_platform_gradle_plugin_dependencies_extension.md). + + +### intelliJPlatformConfiguration +{#IntelliJPlatformVersionAware-intelliJPlatformConfiguration} + +Holds the `intellijPlatform` configuration with the IntelliJ Platform dependency added. + +It should not be directly accessed. + +{style="narrow"} +Type +: `ConfigurableFileCollection` + + +### platformPath +{#IntelliJPlatformVersionAware-platformPath} + +Provides a direct path to the IntelliJ Platform dependency artifact. + +{style="narrow"} +Type +: `Path` + +### productInfo +{#IntelliJPlatformVersionAware-productInfo} + +Provides information about the IntelliJ Platform product. + +The information is retrieved from the product-info.json file in the IntelliJ Platform directory. + +{style="narrow"} +Type +: [`ProductInfo`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo) + + +### validateIntelliJPlatformVersion() +{#IntelliJPlatformVersionAware-validateIntelliJPlatformVersion} + +Validates that the resolved IntelliJ Platform is supported by checking against the minimal supported IntelliJ Platform version. + +Invokes [`ProductInfo.validateSupportedVersion()`](tools_intellij_platform_gradle_plugin_types.md#ProductInfo-validateSupportedVersion). + +{style="narrow"} +Throws +: `IllegalArgumentException` + + +## PluginVerifierAware +{#PluginVerifierAware} + +[`PluginVerifierAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/PluginVerifierAware.kt) + +The interface provides the path to the IntelliJ Plugin Verifier executable. + +It is required to have a dependency on the IntelliJ Plugin Verifier added to the project with [`intellijPlatform.pluginVerifier()`](tools_intellij_platform_gradle_plugin_dependencies_extension.md) dependencies extension. + + +### pluginVerifierExecutable +{#PluginVerifierAware-pluginVerifierExecutable} + +Path to the IntelliJ Plugin Verifier executable. + +{style="narrow"} +Type +: `RegularFileProperty` + + +## RunnableIdeAware +{#RunnableIdeAware} + +[`RunnableIdeAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/RunnableIdeAware.kt) + +The interface which utilizes a set of various interfaces required for running a guest IDE. Inherits from: +- [`CoroutinesJavaAgentAware`](#CoroutinesJavaAgentAware) +- [`RuntimeAware`](#RuntimeAware) +- [`SandboxAware`](#SandboxAware) +- `JavaForkOptions` + + +## RuntimeAware +{#RuntimeAware} + +[`RuntimeAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/RuntimeAware.kt) + +This interface provides access to the Java Runtime (i.e., JetBrains Runtime) resolved with `RuntimeResolver`. + +### runtimeDirectory +{#RuntimeAware-runtimeDirectory} + +Java Runtime parent directory. + +{style="narrow"} +Type +: `DirectoryProperty` + + +### runtimeExecutable +{#RuntimeAware-runtimeExecutable} + +Path to the Java Runtime executable. + +{style="narrow"} +Type +: `RegularFileProperty` + + +### runtimeArch +{#RuntimeAware-runtimeArch} + +An architecture of the Java Runtime currently used for running Gradle. + +{style="narrow"} +Type +: `Property` + + + +## SandboxAware +{#SandboxAware} + +[`SandboxAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/SandboxAware.kt) + +The interface provides quick access to the sandbox container and specific directories located within it. + +The path to the sandbox container is obtained using the [`intellijPlatform.sandboxContainer`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-sandboxContainer) extension property and the type and version of the IntelliJ Platform applied to the project. + +Paths respect custom IntelliJ Platform when combined with [`CustomIntelliJPlatformVersionAware`](#CustomIntelliJPlatformVersionAware). + + +### sandboxSuffix +{#SandboxAware-sandboxSuffix} + +Represents the suffix used i.e., for test-related tasks. + +{style="narrow"} +Type +: `Property` + + +### sandboxContainerDirectory +{#SandboxAware-sandboxContainerDirectory} + +The container for all sandbox-related directories. + +The directory name depends on the platform type and version currently used for running a task. + +{style="narrow"} +Type +: `DirectoryProperty` + + +### sandboxConfigDirectory +{#SandboxAware-sandboxConfigDirectory} + +A configuration directory located within the [`sandboxContainerDirectory`](#SandboxAware-sandboxContainerDirectory). + +{style="narrow"} +Type +: `DirectoryProperty` + + +### sandboxPluginsDirectory +{#SandboxAware-sandboxPluginsDirectory} + +A plugins directory located within the [`sandboxContainerDirectory`](#SandboxAware-sandboxContainerDirectory). + +{style="narrow"} +Type +: `DirectoryProperty` + + +### sandboxSystemDirectory +{#SandboxAware-sandboxSystemDirectory} + +A system directory located within the [`sandboxContainerDirectory`](#SandboxAware-sandboxContainerDirectory). + +{style="narrow"} +Type +: `DirectoryProperty` + + +### sandboxLogDirectory +{#SandboxAware-sandboxLogDirectory} + +A log directory located within the [`sandboxContainerDirectory`](#SandboxAware-sandboxContainerDirectory). + +{style="narrow"} +Type +: `DirectoryProperty` + + +## SigningAware +{#SigningAware} + +[`SigningAware`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/aware/SigningAware.kt) + +The interface provides the path to the Marketplace ZIP Signer executable. + +It is required to have a dependency on the Marketplace ZIP Signer added to the project with [`intellijPlatform.zipSigner()`](tools_intellij_platform_gradle_plugin_dependencies_extension.md) dependencies extension. + + +### zipSignerExecutable +{#SigningAware-zipSignerExecutable} + +Path to the Marketplace ZIP Signer executable. + +{style="narrow"} +Type +: `RegularFileProperty` + + + diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_tasks.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_tasks.md new file mode 100644 index 000000000..8de306c38 --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_tasks.md @@ -0,0 +1,1731 @@ + + +# Tasks + +IntelliJ Platform Gradle Plugin tasks. + + + +The IntelliJ Platform Gradle Plugin introduces a set of tasks to handle activities of the plugin development for IntelliJ-based IDEs, such as building, verifying, testing, and publishing the plugin archive. + +Tasks are applied to the project with the [`org.jetbrains.intellij.platform.tasks`](tools_intellij_platform_gradle_plugin.md#plugin.tasks) subplugin, which is a part of [`org.jetbrains.intellij.platform`](tools_intellij_platform_gradle_plugin.md#plugin.platform). + +Each of the tasks has relations described between each other, inherit from [](tools_intellij_platform_gradle_plugin_task_awares.md) interfaces, respect configuration and build cache, and can be configured independently, but for the most cases, the [](tools_intellij_platform_gradle_plugin_extension.md) covers all necessary cases. + +```mermaid +flowchart LR + + subgraph TASKS ["`**IntelliJ Platform Gradle Plugin Tasks**`"] + direction TB + + initializeIntelliJPlatformPlugin + + subgraph ALL ["` `"] + buildPlugin + buildSearchableOptions + classpathIndexCleanup>classpathIndexCleanup] + instrumentCode>instrumentCode] + instrumentedJar>instrumentedJar] + jarSearchableOptions + patchPluginXml + prepareSandbox + setupDependencies>setupDependencies] + + subgraph PUBLISH ["Publish"] + publishPlugin + signPlugin + end + + subgraph RUN ["Run/Test"] + runIde + testIde + testIdePerformance>testIdePerformance] + testIdeUi>testIdeUi] + end + + subgraph VERIFY ["Verify"] + direction TB + + verifyPluginSignature + verifyPluginProjectConfiguration + verifyPluginStructure + verifyPlugin + end + + subgraph PLATFORM ["Target Platform"] + printBundledPlugins + printProductsReleases + end + end + end + + subgraph GRADLE ["Gradle Tasks"] + test + jar + compileKotlin + end + + + initializeIntelliJPlatformPlugin --> | runs before | ALL + buildPlugin --> jarSearchableOptions & prepareSandbox + jarSearchableOptions --> buildSearchableOptions & prepareSandbox + buildSearchableOptions --> patchPluginXml & prepareSandbox + prepareSandbox --> jar & instrumentedJar + publishPlugin --> buildPlugin & signPlugin + runIde --> prepareSandbox + signPlugin --> buildPlugin + testIde --> prepareSandbox + test --> testIde + verifyPluginProjectConfiguration --> patchPluginXml + verifyPluginSignature --> signPlugin & prepareSandbox + verifyPluginStructure --> prepareSandbox + verifyPlugin --> buildPlugin + + + click buildPlugin "#buildPlugin" + click buildSearchableOptions "#buildSearchableOptions" + click classpathIndexCleanup "#classpathIndexCleanup" + click initializeIntelliJPlatformPlugin "#initializeIntelliJPlatformPlugin" + click instrumentCode "#instrumentCode" + click instrumentedJar "#instrumentedJar" + click jarSearchableOptions "#jarSearchableOptions" + click patchPluginXml "#patchPluginXml" + click prepareSandbox "#prepareSandbox" + click printBundledPlugins "#printBundledPlugins" + click printProductsReleases "#printProductsReleases" + click publishPlugin "#publishPlugin" + click runIde "#runIde" + click setupDependencies "#setupDependencies" + click signPlugin "#signPlugin" + click testIde "#testIde" + click testIdePerformance "#testIdePerformance" + click testIdeUi "#testIdeUi" + click verifyPluginProjectConfiguration "#verifyPluginProjectConfiguration" + click verifyPluginSignature "#verifyPluginSignature" + click verifyPluginStructure "#verifyPluginStructure" + click verifyPlugin "#verifyPlugin" + + style TASKS fill:transparent + style ALL fill:transparent + + style classpathIndexCleanup stroke-dasharray: 5 5 + style instrumentCode stroke-dasharray: 5 5 + style instrumentedJar stroke-dasharray: 5 5 + style setupDependencies stroke-dasharray: 5 5 +``` + +## buildPlugin +{#buildPlugin} + + + +**Depends on**: [`jarSearchableOptions`](#jarSearchableOptions), [`prepareSandbox`](#prepareSandbox) + +**Extends**: [`Zip`][gradle-zip-task] + +**Sources**: [`BuildPluginTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/BuildPluginTask.kt) + + + +Builds the plugin and prepares the ZIP archive for testing and deployment. + +It takes the output of the [`prepareSandbox`](#prepareSandbox) task containing the built project with all its modules and dependencies, and the output of [`jarSearchableOptions`](#jarSearchableOptions) task. + +The produced archive is stored in the [buildDirectory]/distributions/[`archiveFile`](#buildPlugin-archiveFile) file. +The [`archiveFile`](#buildPlugin-archiveFile) name and location can be controlled with properties provided with the [`Zip`](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Zip.html) base task. +By default, the `archiveBaseName` is set to the value of [`prepareSandbox.pluginName`](#prepareSandbox-pluginName). + + +### archiveFile +{#buildPlugin-archiveFile} + +The archive file which represents the output file produced by the task. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`buildPlugin.archiveFile`](#buildPlugin-archiveFile) + + +## buildSearchableOptions +{#buildSearchableOptions} + + + +**Depends on**: [`patchPluginXml`](#patchPluginXml) + +**Extends**: [`JavaExec`][gradle-javaexec-task], [`RunnableIdeAware`](tools_intellij_platform_gradle_plugin_task_awares.md#RunnableIdeAware) + +**Sources**: [`BuildSearchableOptionsTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/BuildSearchableOptionsTask.kt) + + + +Builds the index of UI components (searchable options) for the plugin. +This task runs a headless IDE instance to collect all the available options provided by the plugin's [](settings.md). + +If your plugin doesn't implement custom settings, it is recommended to disable this task via [`intellijPlatform.buildSearchableOptions`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-buildSearchableOptions) build feature. + +In the case of running the task for the plugin using [`intellijPlatform.pluginConfiguration.productDescriptor`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-productDescriptor), a warning will be logged regarding potential issues with running headless IDE for paid plugins. +It is possible to mute this warning with the [`paidPluginSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#paidPluginSearchableOptionsWarning) build feature. + + +### outputDirectory +{#buildSearchableOptions-outputDirectory} + +The directory to which searchable options will be generated. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/searchableOptions + + +### showPaidPluginWarning +{#buildSearchableOptions-showPaidPluginWarning} + +Emit warning if the task is executed by a paid plugin. +Can be disabled with the [`paidPluginSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#paidPluginSearchableOptionsWarning) build feature. + +{style="narrow"} +Type +: `Property` + +Default value +: [`paidPluginSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#paidPluginSearchableOptionsWarning) && `productDescriptor` is defined + + +## classpathIndexCleanup +{#classpathIndexCleanup} + +> Deprecated? +> +{style="warning"} + + +## initializeIntelliJPlatformPlugin +{#initializeIntelliJPlatformPlugin} + + + +**Extends**: [`DefaultTask`][gradle-default-task], [`IntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#IntelliJPlatformVersionAware) + +**Sources**: [`InitializeIntelliJPlatformPluginTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/InitializeIntelliJPlatformPluginTask.kt) + + + +This task is executed before every other task introduced by IntelliJ Platform Gradle Plugin to prepare it to run. + +It is responsible for: +- checking if the project uses IntelliJ Platform Gradle Plugin in the latest available version +- preparing the KotlinX Coroutines Java Agent file to enable coroutines debugging when developing the plugin + +The self-update check can be disabled via [`selfUpdateCheck`](tools_intellij_platform_gradle_plugin_build_features.md#selfUpdateCheck) build feature. + +To make the Coroutines Java Agent available for the task, inherit from [`CoroutinesJavaAgentAware`](tools_intellij_platform_gradle_plugin_task_awares.md#CoroutinesJavaAgentAware). + + +### offline +{#initializeIntelliJPlatformPlugin-offline} + +Determines if the operation is running in offline mode. + +Depends on Gradle start parameters. + +{style="narrow"} +Type +: `Property` + +Default value +: `StartParameter.isOffline` + +See also: +- [StartParameter](https://docs.gradle.org/current/javadoc/org/gradle/StartParameter.html) +- [Command Line Execution Options](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_execution_options) + + +### selfUpdateCheck +{#initializeIntelliJPlatformPlugin-selfUpdateCheck} + +Represents the property for checking if self-update checks are enabled. + +{style="narrow"} +Type +: `Property` + +Default value +: [`selfUpdateCheck`](tools_intellij_platform_gradle_plugin_build_features.md#selfUpdateCheck) + + +### selfUpdateLock +{#initializeIntelliJPlatformPlugin-selfUpdateLock} + +Represents a lock file used to limit the plugin version checks in time. +If the file is absent, and other conditions are met, the version check is performed. + +{style="narrow"} +Type +: `RegularFileProperty` + + +### coroutinesJavaAgent +{#initializeIntelliJPlatformPlugin-coroutinesJavaAgent} + +Java Agent file for the Coroutines library, which is required to enable coroutines debugging. + +{style="narrow"} +Type +: `Property` + +Default value +: [buildDirectory]/tmp/initializeIntelliJPlatformPlugin/coroutines-javaagent.jar + + +### pluginVersion +{#initializeIntelliJPlatformPlugin-pluginVersion} + +Represents the current version of the plugin. + +{style="narrow"} +Type +: `Property` + + +## instrumentCode +{#instrumentCode} + +> Not implemented. +> +{style="warning"} + +See also: +- [Extension: `intellijPlatform.instrumentCode`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-instrumentCode) + + +## instrumentedJar +{#instrumentedJar} + +> Not implemented. +> +{style="warning"} + + +## jarSearchableOptions +{#jarSearchableOptions} + + + +**Depends on**: [`buildSearchableOptions`](#buildSearchableOptions) + +**Extends**: [`Jar`][gradle-jar-task], [`SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware) + +**Sources**: [`JarSearchableOptionsTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/JarSearchableOptionsTask.kt) + + + +Creates a JAR file with searchable options to be distributed with the plugin. + + +### destinationDirectory +{#jarSearchableOptions-destinationDirectory} + +The directory where the JAR file will be created. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/libsSearchableOptions + + +### inputDirectory +{#jarSearchableOptions-inputDirectory} + +The directory from which + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/tmp/initializeIntelliJPlatformPlugin/coroutines-javaagent.jar + + +### noSearchableOptionsWarning +{#jarSearchableOptions-noSearchableOptionsWarning} + +Emit warning if no searchable options are found. +Can be disabled with [`noSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#noSearchableOptionsWarning) build feature. + +{style="narrow"} +Type +: `Property` + +Default value +: [`noSearchableOptionsWarning`](tools_intellij_platform_gradle_plugin_build_features.md#noSearchableOptionsWarning) + + +### pluginName +{#jarSearchableOptions-pluginName} + +The name of the plugin. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.name`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-name) + + +## patchPluginXml +{#patchPluginXml} + + + +**Extends**: [`DefaultTask`][gradle-default-task], [`IntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#IntelliJPlatformVersionAware) + +**Sources**: [`PatchPluginXmlTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/PatchPluginXmlTask.kt) + + + + +### inputFile +{#patchPluginXml-inputFile} + +Represents an input plugin.xml file. + +By default, a plugin.xml file is picked from the main resource location. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: src/main//resources/META-INF/plugin.xml + + +### outputFile +{#patchPluginXml-outputFile} + +Represents the output plugin.xml file property for the task. + +By default, the file is written to a temporary task-specific directory within the build directory. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [buildDirectory]/tmp/patchPluginXml/plugin.xml + + +### pluginId +{#patchPluginXml-pluginId} + +A unique identifier of the plugin. + +It should be a fully qualified name similar to Java packages and must not collide with the ID of existing plugins. +The ID is a technical value used to identify the plugin in the IDE and [JetBrains Marketplace](https://plugins.jetbrains.com/). + +Please use characters, numbers, and `.`/`-`/`_` symbols only and keep it reasonably short. + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.id`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-id) + +See also: +- [Plugin Configuration File: `id`](plugin_configuration_file.md#idea-plugin__id) + + +### pluginName +{#patchPluginXml-pluginName} + +The user-visible plugin display name (Title Case). + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.name`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-name) + +See also: +- [Plugin Configuration File: `name`](plugin_configuration_file.md#idea-plugin__name) + + +### pluginVersion +{#patchPluginXml-pluginVersion} + +The plugin version is displayed in the Plugins settings dialog and on the JetBrains Marketplace plugin page. + +Plugins uploaded to the JetBrains Marketplace must follow semantic versioning. + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.version`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-version) + +See also: +- [Plugin Configuration File: `version`](plugin_configuration_file.md#idea-plugin__version) + + +### pluginDescription +{#patchPluginXml-pluginDescription} + +The plugin description is displayed on the JetBrains Marketplace plugin page and in the Plugins settings dialog. +Simple HTML elements, like text formatting, paragraphs, lists, etc., are allowed. + +The description content is automatically wrapped with ``. + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.description`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-description) + +See also: +- [Plugin Configuration File: `description`](plugin_configuration_file.md#idea-plugin__description) + + +### changeNotes +{#patchPluginXml-changeNotes} + +A short summary of new features, bugfixes, and changes provided with the latest plugin version. +Change notes are displayed on the JetBrains Marketplace plugin page and in the Plugins settings dialog. +Simple HTML elements, like text formatting, paragraphs, lists, etc., are allowed. + +The change notes content is automatically wrapped with ``. + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.changeNotes`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-changeNotes) + +See also: +- [Plugin Configuration File: `change-notes`](plugin_configuration_file.md#idea-plugin__change-notes) + + +### productDescriptorCode +{#patchPluginXml-productDescriptorCode} + +The plugin product code used in the JetBrains Sales System. +The code must be agreed with JetBrains in advance and follow [the requirements](https://plugins.jetbrains.com/docs/marketplace/obtain-a-product-code-from-jetbrains.html). + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.productDescriptor.code`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-productDescriptor-code) + +See also: +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### productDescriptorReleaseDate +{#patchPluginXml-productDescriptorReleaseDate} + +Date of the major version release in the `YYYYMMDD` format. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.productDescriptor.releaseDate`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-productDescriptor-releaseDate) + +See also: +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### productDescriptorReleaseVersion +{#patchPluginXml-productDescriptorReleaseVersion} + +A major version in a special number format. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.productDescriptor.releaseVersion`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-productDescriptor-releaseVersion) + +See also: +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### productDescriptorOptional +{#patchPluginXml-productDescriptorOptional} + +The boolean value determining whether the plugin is a [Freemium](https://plugins.jetbrains.com/docs/marketplace/freemium.html) plugin. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.productDescriptor.optional`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-productDescriptor-optional) + +Default value +: `false` + +See also: +- [Plugin Configuration File: `product-descriptor`](plugin_configuration_file.md#idea-plugin__product-descriptor) + + +### sinceBuild +{#patchPluginXml-sinceBuild} + +The lowest IDE version compatible with the plugin. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.ideaVersion.sinceBuild`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-ideaVersion-sinceBuild) + +See also: +- [Plugin Configuration File: `idea-version`](plugin_configuration_file.md#idea-plugin__idea-version) + + +### untilBuild +{#patchPluginXml-untilBuild} + +The highest IDE version compatible with the plugin. +Undefined value declares compatibility with all the IDEs since the version specified by the `since-build` (also with the future builds that may cause incompatibility errors). + +The provided value will be set as a value of the `` element attribute. + +The `until-build` attribute can be unset by setting `provider { null }` as a value. +Note that passing only `null` will make Gradle use a default value instead. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.ideaVersion.untilBuild`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-ideaVersion-untilBuild) + +See also: +- [Plugin Configuration File: `idea-version`](plugin_configuration_file.md#idea-plugin__idea-version) + + +### vendorName +{#patchPluginXml-vendorName} + +The vendor name or organization ID (if created) in the Plugins settings dialog and on the JetBrains Marketplace plugin page. + +The provided value will be set as a value of the `` element. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.vendor.name`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-vendor-name) + +See also: +- [Plugin Configuration File: `vendor`](plugin_configuration_file.md#idea-plugin__vendor) + + +### vendorEmail +{#patchPluginXml-vendorEmail} + +The vendor's email address. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.vendor.email`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-vendor-email) + +See also: +- [Plugin Configuration File: `vendor`](plugin_configuration_file.md#idea-plugin__vendor) + + +### vendorUrl +{#patchPluginXml-vendorUrl} + +The link to the vendor's homepage. + +The provided value will be set as a value of the `` element attribute. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.vendor.url`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-vendor-url) + +See also: +- [Plugin Configuration File: `vendor`](plugin_configuration_file.md#idea-plugin__vendor) + + +## prepareSandbox +{#prepareSandbox} + + + +**Depends on**: `jar`, [`instrumentedJar`](#instrumentedJar) + +**Extends**: [`Sync`][gradle-jar-task], [`SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware) + +**Sources**: [`PrepareSandboxTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/PrepareSandboxTask.kt) + + + +Prepares a sandbox environment with the installed plugin and its dependencies. + +The sandbox directory is required by tasks that run IDE and tests in isolation from other instances, like when multiple IntelliJ Platforms are used for testing with [`runIde`](#runIde), [`testIde`](#testIde), [`testIdeUi`](#testIdeUi), or [`testIdePerformance`](#testIdePerformance) tasks. + +To fully utilize the sandbox capabilities in a task, extend from [`SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware) interface. + +See also: +- [Extension: `intellijPlatform.sandboxContainer`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-sandboxContainer) + + +### defaultDestinationDirectory +{#prepareSandbox-defaultDestinationDirectory} + +Default sandbox destination directory to where the plugin files will be copied into. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [`SandboxAware.sandboxPluginsDirectory`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware-sandboxPluginsDirectory) + + +### pluginName +{#prepareSandbox-pluginName} + +The name of the plugin. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.pluginConfiguration.name`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-name) + + +### pluginJar +{#prepareSandbox-pluginJar} + +The output of `Jar` task. +The proper `Jar.archiveFile` is picked depending on if code instrumentation is enabled. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: `Jar.archiveFile` + +See also: +- [Extension: `intellijPlatform.instrumentCode`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-instrumentCode) + + +### pluginsClasspath +{#prepareSandbox-pluginsClasspath} + +List of dependencies on external plugins resolved from the `intellijPlatformPluginsExtracted` configuration. + +{style="narrow"} +Type +: `ConfigurableFileCollection` + +See also: +- [Dependencies Extension](tools_intellij_platform_gradle_plugin_dependencies_extension.md) + + +### runtimeClasspath +{#prepareSandbox-runtimeClasspath} + +Dependencies defined with the `runtimeClasspath` configuration. + +{style="narrow"} +Type +: `ConfigurableFileCollection` + + +## printBundledPlugins +{#printBundledPlugins} + + + +**Extends**: [`DefaultTask`][gradle-default-task], [`IntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#IntelliJPlatformVersionAware) + +**Sources**: [`PrintBundledPluginsTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/PrintBundledPluginsTask.kt) + + + +Prints the list of bundled plugins available within the currently targeted IntelliJ Platform. + + +## printProductsReleases +{#printProductsReleases} + + + +**Extends**: [`DefaultTask`][gradle-default-task] + +**Sources**: [`PrintProductsReleasesTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/PrintProductsReleasesTask.kt) + + + +Prints the list of binary product releases that, by default, match the currently selected IntelliJ Platform along with [`intellijPlatform.pluginConfiguration.ideaVersion.sinceBuild`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-ideaVersion-sinceBuild) and [`intellijPlatform.pluginConfiguration.ideaVersion.untilBuild`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-ideaVersion-untilBuild) properties. + + +### productsReleases +{#printProductsReleases-productsReleases} + +Property holds the list of product releases to print. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: The output of `ProductReleasesValueSource` using default configuration + + +## publishPlugin +{#publishPlugin} + + + +**Depends on**: [`buildPlugin`](#buildPlugin), [`signPlugin`](#signPlugin) + +**Extends**: [`DefaultTask`][gradle-default-task] + +**Sources**: [`PublishPluginTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/PublishPluginTask.kt) + + + +The task for publishing plugin to the remote plugins repository, such as [JetBrains Marketplace](https://plugins.jetbrains.com). + +See also: +- [Uploading a Plugin to JetBrains Marketplace](publishing_plugin.md#uploading-a-plugin-to-jetbrains-marketplace) +- [Publishing Plugin With Gradle](publishing_plugin.md#publishing-plugin-with-gradle) +- [Plugin upload API](https://plugins.jetbrains.com/docs/marketplace/plugin-upload.html) + + +### archiveFile +{#publishPlugin-archiveFile} + +ZIP archive to be published to the remote repository. + +By default, it uses the output `archiveFile` of the [`signPlugin`](#signPlugin) task if plugin signing is configured, otherwise the one from [`buildPlugin`](#buildPlugin). + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`signPlugin.archiveFile`](#signPlugin-archiveFile) or [`buildPlugin.archiveFile`](#buildPlugin-archiveFile) + +See also: +- [Extension: `intellijPlatform.signing`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing) + + +### host +{#publishPlugin-host} + +URL host of a plugin repository. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.publishing.host`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-publishing-host) + + +### token +{#publishPlugin-token} + +Authorization token. + +{style="narrow"} +Type +: `Property` + +Required +: yes + +Default value +: [`intellijPlatform.publishing.token`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-publishing-token) + + +### channels +{#publishPlugin-channels} + +A list of channel names to upload plugin to. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: [`intellijPlatform.publishing.channels`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-publishing-channels) + + +### hidden +{#publishPlugin-hidden} + +Publish the plugin update and mark it as hidden to prevent public release after approval. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.publishing.hidden`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-publishing-hidden) + +See also: +- [Hidden release](https://plugins.jetbrains.com/docs/marketplace/hidden-plugin.html) + + +### toolboxEnterprise +{#publishPlugin-toolboxEnterprise} + +Specifies if the Toolbox Enterprise plugin repository service should be used. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.publishing.toolboxEnterprise`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-publishing-toolboxEnterprise) + + +## runIde +{#runIde} + + + +**Extends**: [`JavaExec`][gradle-javaexec-task], [`RunnableIdeAware`](tools_intellij_platform_gradle_plugin_task_awares.md#RunnableIdeAware), [`CustomIntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#CustomIntelliJPlatformVersionAware) + +**Sources**: [`RunIdeTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/RunIdeTask.kt) + + + +Runs the IDE instance using the currently selected IntelliJ Platform with the built plugin loaded. +It directly extends the [`JavaExec`][gradle-javaexec-task] Gradle task, which allows for an extensive configuration (system properties, memory management, etc.). + +This task class also inherits from [`CustomIntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#CustomIntelliJPlatformVersionAware), which makes it possible to create `runIde`-like tasks using custom IntelliJ Platform versions: + +```kotlin +import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType +import org.jetbrains.intellij.platform.gradle.tasks.RunIdeTask + +tasks { + val runPhpStorm by registering(RunIdeTask::class) { + type = IntelliJPlatformType.PhpStorm + version = "2023.2.2" + } + + val runLocalIde by registering(RunIdeTask::class) { + localPath = file("/Users/hsz/Applications/Android Studio.app") + } +} +``` + + +## setupDependencies +{#setupDependencies} + +> Deprecated. See [Migration FAQ](tools_intellij_platform_gradle_plugin_migration.md#setupdependencies-task). +> +{style="warning"} + + +## signPlugin +{#signPlugin} + + + +**Depends on**: [`buildPlugin`](#buildPlugin) + +**Extends**: [`JavaExec`][gradle-javaexec-task], [`SigningAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SigningAware) + +**Sources**: [`SignPluginTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/SignPluginTask.kt) + + + +Signs the ZIP archive with the provided key using the [Marketplace ZIP Signer](https://github.com/JetBrains/marketplace-zip-signer) library. + +To sign the plugin before publishing to [JetBrains Marketplace](https://plugins.jetbrains.com) with the [`signPlugin`](#signPlugin) task, it is required to provide a certificate chain and a private key with its password using [`intellijPlatform.signing`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing) extension. + +As soon as [`privateKey`](#signPlugin-privateKey) (or [`privateKeyFile`](#signPlugin-privateKeyFile)) and [`certificateChain`](#signPlugin-certificateChain) (or [`certificateChainFile`](#signPlugin-certificateChainFile) properties are specified, the task will be executed automatically right before the [`publishPlugin`](#publishPlugin) task. + +For more details, see [](plugin_signing.md). + + +### archiveFile +{#signPlugin-archiveFile} + +Input, unsigned ZIP archive file. +Refers to `in` CLI option. + +By default, it uses the output archive of the [`buildPlugin`](#buildPlugin) task. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`buildPlugin.archiveFile`](#buildPlugin-archiveFile) + + +### signedArchiveFile +{#signPlugin-signedArchiveFile} + +Output, signed ZIP archive file. +Refers to `out` CLI option. + +Predefined with the name of the ZIP archive file with `-signed` name suffix attached. +The output file is placed next to the input [`archiveFile`](#signPlugin-archiveFile). + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`signPlugin.archiveFile`](#signPlugin-archiveFile) with `-signed` suffix applied to the name + + +### keyStore +{#signPlugin-keyStore} + +KeyStore file path. +Refers to `ks` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.keyStore`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-keyStore) + + +### keyStorePassword +{#signPlugin-keyStorePassword} + +KeyStore password. +Refers to `ks-pass` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.keyStorePassword`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-keyStorePassword) + + +### keyStoreKeyAlias +{#signPlugin-keyStoreKeyAlias} + +KeyStore key alias. +Refers to `ks-key-alias` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.keyStoreKeyAlias`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-keyStoreKeyAlias) + + +### keyStoreType +{#signPlugin-keyStoreType} + +KeyStore type. +Refers to `ks-type` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.keyStoreType`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-keyStoreType) + + +### keyStoreProviderName +{#signPlugin-keyStoreProviderName} + +JCA KeyStore Provider name. +Refers to `ks-provider-name` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.keyStoreProviderName`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-keyStoreProviderName) + + +### privateKey +{#signPlugin-privateKey} + +Encoded private key in the PEM format. +Refers to `key` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.privateKey`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-privateKey) + + +### privateKeyFile +{#signPlugin-privateKeyFile} + +A file with an encoded private key in the PEM format. +Refers to `key-file` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`intellijPlatform.signing.privateKeyFile`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-privateKeyFile) + + +### password +{#signPlugin-password} + +Password required to decrypt the private key. +Refers to `key-pass` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.password`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-password) + + +### certificateChain +{#signPlugin-certificateChain} + +A string containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert` CLI option. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.signing.certificateChain`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-certificateChain) + + +### certificateChainFile +{#signPlugin-certificateChainFile} + +Path to the file containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert-file` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`intellijPlatform.signing.certificateChainFile`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-signing-certificateChainFile) + + +## testIde +{#testIde} + + + + +**Extends**: [`Test`][gradle-test-task], [`RunnableIdeAware`](tools_intellij_platform_gradle_plugin_task_awares.md#RunnableIdeAware), [`CustomIntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#CustomIntelliJPlatformVersionAware) + +**Sources**: [`TestIdeTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/TestIdeTask.kt) + + + +Runs plugin tests against the currently selected IntelliJ Platform with the built plugin loaded. +It directly extends the [`Test`][gradle-test-task] Gradle task, which allows for an extensive configuration (system properties, memory management, etc.). + +This task class also inherits from [`CustomIntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#CustomIntelliJPlatformVersionAware), which makes it possible to create `testIde`-like tasks using custom IntelliJ Platform versions: + +```kotlin +import org.jetbrains.intellij.platform.gradle.IntelliJPlatformType +import org.jetbrains.intellij.platform.gradle.tasks.TestIdeTask + +tasks { + val testPhpStorm by registering(TestIdeTask::class) { + type = IntelliJPlatformType.PhpStorm + version = "2023.2.2" + } + + val testLocalIde by registering(TestIdeTask::class) { + localPath = file("/Users/hsz/Applications/Android Studio.app") + } +} +``` + + +## testIdePerformance +{#testIdePerformance} + +> Not implemented. +> +{style="warning"} + + +## testIdeUi +{#testIdeUi} + +> Not implemented. +> +{style="warning"} + + +## verifyPluginProjectConfiguration +{#verifyPluginProjectConfiguration} + + + +**Depends on**: [`patchPluginXml`](#patchPluginXml) + +**Extends**: [`DefaultTask`][gradle-default-task], [`IntelliJPlatformVersionAware`](tools_intellij_platform_gradle_plugin_task_awares.md#IntelliJPlatformVersionAware) + +**Sources**: [`VerifyPluginProjectConfigurationTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginProjectConfigurationTask.kt) + + + +Validates the plugin project configuration: +- The [`patchPluginXml.sinceBuild`](#patchPluginXml-sinceBuild) property can't be lower than the target IntelliJ Platform major version. +- The Java/Kotlin `sourceCompatibility` and `targetCompatibility` properties should align Java versions required by [`patchPluginXml.sinceBuild`](#patchPluginXml-sinceBuild) and the currently used IntelliJ Platform. +- The Kotlin API version should align the version required by [`patchPluginXml.sinceBuild`](#patchPluginXml-sinceBuild) and the currently used IntelliJ Platform. +- The used IntelliJ Platform version should be higher than `2022.3` (`223.0`). +- The dependency on the [](using_kotlin.md#kotlin-standard-library) should be excluded. +- The Kotlin plugin in version `1.8.20` is not used with IntelliJ Platform Gradle Plugin due to the 'java.lang.OutOfMemoryError: Java heap space' exception. +- The Kotlin Coroutines library should not be added explicitly to the project as it is already provided with the IntelliJ Platform. + +For more details regarding the Java version used in the specific IntelliJ SDK, see [](build_number_ranges.md). + +See also: +- [](build_number_ranges.md) +- [](using_kotlin.md#kotlin-standard-library) +- [](using_kotlin.md#incremental-compilation) + + +### pluginXmlFile +{#verifyPluginProjectConfiguration-pluginXmlFile} + +The location of the built plugin file which will be used for verification. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`patchPluginXml.outputFile`](#patchPluginXml-outputFile) + + +### reportDirectory +{#verifyPluginProjectConfiguration-reportDirectory} + +Report directory where the verification result will be stored. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [buildDirectory]/reports/verifyPluginConfiguration + + +### sourceCompatibility +{#verifyPluginProjectConfiguration-sourceCompatibility} + +The `JavaCompile.sourceCompatibility` property value defined in the build script. + +{style="narrow"} +Type +: `Property` + +Default value +: `JavaCompile.sourceCompatibility` + + +### targetCompatibility +{#verifyPluginProjectConfiguration-targetCompatibility} + +The `JavaCompile.targetCompatibility` property value defined in the build script. + +{style="narrow"} +Type +: `Property` + +Default value +: `JavaCompile.targetCompatibility` + + +### kotlinPluginAvailable +{#verifyPluginProjectConfiguration-kotlinPluginAvailable} + +Indicates that the Kotlin Gradle Plugin is loaded and available. + +{style="narrow"} +Type +: `Property` + +Default value +: Kotlin Gradle Plugin presence + + +### kotlinApiVersion +{#verifyPluginProjectConfiguration-kotlinApiVersion} + +The `apiVersion` property value of `compileKotlin.kotlinOptions` defined in the build script. + +{style="narrow"} +Type +: `Property` + +Default value +: `compileKotlin.kotlinOptions.apiVersion` + + +### kotlinLanguageVersion +{#verifyPluginProjectConfiguration-kotlinLanguageVersion} + +The `languageVersion` property value of `compileKotlin.kotlinOptions` defined in the build script. + +{style="narrow"} +Type +: `Property` + +Default value +: `compileKotlin.kotlinOptions.languageVersion` + + +### kotlinVersion +{#verifyPluginProjectConfiguration-kotlinVersion} + +The version of the Kotlin used in the project. + +{style="narrow"} +Type +: `Property` + +Default value +: `kotlin.coreLibrariesVersion` + + +### kotlinJvmTarget +{#verifyPluginProjectConfiguration-kotlinJvmTarget} + +The `jvmTarget` property value of `compileKotlin.kotlinOptions` defined in the build script. + +{style="narrow"} +Type +: `Property` + +Default value +: `compileKotlin.kotlinOptions.jvmTarget` + + +### kotlinStdlibDefaultDependency +{#verifyPluginProjectConfiguration-kotlinStdlibDefaultDependency} + +`kotlin.stdlib.default.dependency` property value defined in the `gradle.properties` file. + +{style="narrow"} +Type +: `Property` + +Default value +: `kotlin.stdlib.default.dependency` Gradle property + + +### kotlinIncrementalUseClasspathSnapshot +{#verifyPluginProjectConfiguration-kotlinIncrementalUseClasspathSnapshot} + +`kotlin.incremental.useClasspathSnapshot` property value defined in the `gradle.properties` file. + +{style="narrow"} +Type +: `Property` + +Default value +: `kotlin.incremental.useClasspathSnapshot` Gradle property + + +### kotlinxCoroutinesLibraryPresent +{#verifyPluginProjectConfiguration-kotlinxCoroutinesLibraryPresent} + +This variable represents whether the Kotlin Coroutines library is added explicitly to the project dependencies. + +{style="narrow"} +Type +: `Property` + +Default value +: The `org.jetbrains.kotlinx:kotlinx-coroutines` dependency presence + + +## verifyPluginSignature +{#verifyPluginSignature} + + + +**Depends on**: [`signPlugin`](#signPlugin) + +**Extends**: [`JavaExec`][gradle-javaexec-task], [`SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SigningAware) + +**Sources**: [`PrepareSandboxTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginSignatureTask.kt) + + + +Validates the signature of the plugin archive file using the [Marketplace ZIP Signer](https://github.com/JetBrains/marketplace-zip-signer) library. + +See also: +- [](plugin_signing.md) +- [Marketplace ZIP Signer](https://github.com/JetBrains/marketplace-zip-signer) + + +### inputArchiveFile +{#verifyPluginSignature-inputArchiveFile} + +Input, unsigned ZIP archive file. +Refers to `in` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`signPlugin.signedArchiveFile`](#signPlugin-signedArchiveFile) + + +### certificateChain +{#verifyPluginSignature-certificateChain} + +A string containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert` CLI option. + +Takes precedence over the [`certificateChainFile`](#verifyPluginSignature-certificateChainFile) property. + +{style="narrow"} +Type +: `Property` + + +### certificateChainFile +{#verifyPluginSignature-certificateChainFile} + +Path to the file containing X509 certificates. +The first certificate from the chain will be used as a certificate authority (CA). +Refers to `cert-file` CLI option. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`signPlugin.certificateChainFile`](#signPlugin-certificateChainFile) or [`signPlugin.certificateChain`](#signPlugin-certificateChain) written to a temporary file + + +## verifyPluginStructure +{#verifyPluginStructure} + + + +**Extends**: [`DefaultTask`][gradle-default-task], [`SandboxAware`](tools_intellij_platform_gradle_plugin_task_awares.md#SandboxAware) + +**Sources**: [`VerifyPluginStructureTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginStructureTask.kt) + + + +Validates completeness and contents of `plugin.xml` descriptors as well as plugin archive structure. + +See also: +- [](plugin_configuration_file.md) + + +### ignoreFailures +{#verifyPluginStructure-ignoreFailures} + +Specifies whether the build should fail when the verifications performed by this task fail. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + + +### ignoreUnacceptableWarnings +{#verifyPluginStructure-ignoreUnacceptableWarnings} + +Specifies whether the build should fail when the verifications performed by this task emit unacceptable warnings. + +{style="narrow"} +Type +: `Property` + +Default value +: `false` + + +### ignoreWarnings +{#verifyPluginStructure-ignoreWarnings} + +Specifies whether the build should fail when the verifications performed by this task emit warnings. + +{style="narrow"} +Type +: `Property` + +Default value +: `true` + + +### pluginDirectory +{#verifyPluginStructure-pluginDirectory} + +The location of the built plugin file which will be used for verification. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [`prepareSandbox.defaultDestinationDirectory`](#prepareSandbox-defaultDestinationDirectory)/[`intellijPlatform.pluginConfiguration.name`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-pluginConfiguration-name) + + +## verifyPlugin +{#verifyPlugin} + + + +**Depends on**: [`buildPlugin`](#buildPlugin) + +**Extends**: [`JavaExec`][gradle-javaexec-task], [`RuntimeAware`](tools_intellij_platform_gradle_plugin_task_awares.md#RuntimeAware), [`PluginVerifierAware`](tools_intellij_platform_gradle_plugin_task_awares.md#PluginVerifierAware) + +**Sources**: [`VerifyPluginTask`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginTask.kt) + + + +Runs the IntelliJ Plugin Verifier CLI tool to check the binary compatibility with specified IDE builds. + +See also: +- [Extension: `intellijPlatform.verifyPlugin`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin) +- [Types: `FailureLevel`](tools_intellij_platform_gradle_plugin_types.md#FailureLevel) +- [Types: `Subsystems`](tools_intellij_platform_gradle_plugin_types.md#Subsystems) +- [Types: `VerificationReportsFormats`](tools_intellij_platform_gradle_plugin_types.md#VerificationReportsFormats) +- [Verifying Plugin Compatibility](verifying_plugin_compatibility.md) +- [IntelliJ Plugin Verifier](https://github.com/JetBrains/intellij-plugin-verifier) + + +### ides +{#verifyPlugin-ides} + +Holds a reference to IntelliJ Platform IDEs which will be used by the IntelliJ Plugin Verifier CLI tool for the binary plugin verification. + +The list of IDEs is controlled with the [`intellijPlatform.verifyPlugin.ides`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-ides) extension. + +{style="narrow"} +Type +: `ConfigurableFileCollection` + + +### archiveFile +{#verifyPlugin-archiveFile} + +Input ZIP archive file of the plugin to verify. +If empty, the task will be skipped. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`buildPlugin.archiveFile`](#buildPlugin-archiveFile) + + +### externalPrefixes +{#verifyPlugin-externalPrefixes} + +The list of class prefixes from the external libraries. +The Plugin Verifier will not report `No such class` for classes of these packages. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: [`intellijPlatform.verifyPlugin.externalPrefixes`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-externalPrefixes) + + +### failureLevel +{#verifyPlugin-failureLevel} + +Defines the verification level at which the task should fail if any reported issue matches. + +{style="narrow"} +Type +: [`ListProperty`](tools_intellij_platform_gradle_plugin_types.md#FailureLevel) + +Default value +: [`intellijPlatform.verifyPlugin.failureLevel`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-failureLevel) + + +### freeArgs +{#verifyPlugin-freeArgs} + +The list of free arguments is passed directly to the IntelliJ Plugin Verifier CLI tool. + +They can be used in addition to the arguments that are provided by dedicated options. + +{style="narrow"} +Type +: `ListProperty` + +Default value +: [`intellijPlatform.verifyPlugin.freeArgs`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-freeArgs) + + +### ignoredProblemsFile +{#verifyPlugin-ignoredProblemsFile} + +A file that contains a list of problems that will be ignored in a report. + +{style="narrow"} +Type +: `RegularFileProperty` + +Default value +: [`intellijPlatform.verifyPlugin.ignoredProblemsFile`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-ignoredProblemsFile) + + +### offline +{#verifyPlugin-offline} + +Determines if the operation is running in offline mode. + +Depends on Gradle start parameters + +{style="narrow"} +Type +: `Property` + +Default value +: `StartParameter.isOffline` + +See also: +- [StartParameter](https://docs.gradle.org/current/javadoc/org/gradle/StartParameter.html) +- [Command Line Execution Options](https://docs.gradle.org/current/userguide/command_line_interface.html#sec:command_line_execution_options) + + +### subsystemsToCheck +{#verifyPlugin-subsystemsToCheck} + +Specifies which subsystems of IDE should be checked. + +{style="narrow"} +Type +: [`Subsystems`](tools_intellij_platform_gradle_plugin_types.md#Subsystems) + +Default value +: [`intellijPlatform.verifyPlugin.subsystemsToCheck`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-subsystemsToCheck) + + +### teamCityOutputFormat +{#verifyPlugin-teamCityOutputFormat} + +A flag that controls the output format. +If set to `true`, the TeamCity compatible output will be returned to stdout. + +{style="narrow"} +Type +: `Property` + +Default value +: [`intellijPlatform.verifyPlugin.teamCityOutputFormat`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-teamCityOutputFormat) + + +### verificationReportsDirectory +{#verifyPlugin-verificationReportsDirectory} + +The path to the directory where verification reports will be saved. + +{style="narrow"} +Type +: `DirectoryProperty` + +Default value +: [`intellijPlatform.verifyPlugin.verificationReportsDirectory`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-verificationReportsDirectory) + + +### verificationReportsFormats +{#verifyPlugin-verificationReportsFormats} + +The output formats of the verification reports. + +{style="narrow"} +Type +: [`ListProperty`](tools_intellij_platform_gradle_plugin_types.md#VerificationReportsFormats) + +Default value +: [`intellijPlatform.verifyPlugin.verificationReportsFormats`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-verificationReportsFormats) + + + + +[gradle-default-task]: https://docs.gradle.org/current/dsl/org.gradle.api.DefaultTask.html +[gradle-jar-task]: https://docs.gradle.org/current/dsl/org.gradle.jvm.tasks.Jar.html +[gradle-javaexec-task]: https://docs.gradle.org/current/dsl/org.gradle.api.tasks.JavaExec.html +[gradle-sync-task]: https://docs.gradle.org/current/dsl/org.gradle.api.tasks.Sync.html +[gradle-test-task]: https://docs.gradle.org/current/dsl/org.gradle.api.tasks.testing.Test.html +[gradle-zip-task]: https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Zip.html diff --git a/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_types.md b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_types.md new file mode 100644 index 000000000..58a10b94c --- /dev/null +++ b/topics/appendix/tools/intellij_platform_gradle_plugin/tools_intellij_platform_gradle_plugin_types.md @@ -0,0 +1,179 @@ + + +# Types + +IntelliJ Platform Gradle Plugin data types, enums, and constants. + + + +## FailureLevel +{#FailureLevel} + +[`VerifyPluginTask.FailureLevel`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginTask.kt) + +Enum class describing the failure level of the IntelliJ Plugin Verifier CLI tool run with the [`verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) task. + +| Name | Description | +|------------------------------------|-------------------------------------------------------------------------------------| +| `COMPATIBILITY_WARNINGS` | Compatibility warnings detected against the specified IDE version. | +| `COMPATIBILITY_PROBLEMS` | Compatibility problems detected against the specified IDE version. | +| `DEPRECATED_API_USAGES` | Plugin uses API marked as deprecated (`@Deprecated`). | +| `SCHEDULED_FOR_REMOVAL_API_USAGES` | Plugin uses API marked as scheduled for removal (`ApiStatus.@ScheduledForRemoval`). | +| `EXPERIMENTAL_API_USAGES` | Plugin uses API marked as experimental (`ApiStatus.@Experimental`). | +| `INTERNAL_API_USAGES` | Plugin uses API marked as internal (`ApiStatus.@Internal`). | +| `OVERRIDE_ONLY_API_USAGES` | Override-only API is used incorrectly (`ApiStatus.@OverrideOnly`). | +| `NON_EXTENDABLE_API_USAGES` | Non-extendable API is used incorrectly (`ApiStatus.@NonExtendable`). | +| `PLUGIN_STRUCTURE_WARNINGS` | The structure of the plugin is not valid. | +| `MISSING_DEPENDENCIES` | Plugin has some dependencies missing. | +| `INVALID_PLUGIN` | Provided plugin artifact is not valid. | +| `NOT_DYNAMIC` | Plugin probably cannot be enabled or disabled without IDE restart | +| `ALL` | Contains all possible options. | +| `NONE` | Contains no option. | + +See also: +- [Extension: `intellijPlatform.verifyPlugin.failureLevel`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-failureLevel) +- [Tasks: `verifyPlugin.failureLevel`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-failureLevel) + + +## IntelliJPlatformType +{#IntelliJPlatformType} + +[`IntelliJPlatformType`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/IntelliJPlatformType.kt) + +Describes all IntelliJ Platform types available to be used for plugin development, dependency resolution, and plugin verification. + +Each entry is composed of a product code name and coordinates used for dependency and binary release resolution. + +| Name | Code | Coordinates | +|-------------------------|--------|----------------------------------------------------| +| `AndroidStudio` | `AI` | `com.google.android.studio:studio` | +| `CLion` | `CL` | `com.jetbrains.intellij.clion:clion` | +| `Fleet` | `FLIJ` | `com.jetbrains.intellij.fleetBackend:fleetBackend` | +| `Gateway` | `GW` | `com.jetbrains.intellij.gateway:gateway` | +| `GoLand` | `GO` | `com.jetbrains.intellij.goland:goland` | +| `IntellijIdeaCommunity` | `IC` | `com.jetbrains.intellij.idea:ideaIC` | +| `IntellijIdeaUltimate` | `IU` | `com.jetbrains.intellij.idea:ideaIU` | +| `PhpStorm` | `PS` | `com.jetbrains.intellij.phpstorm:phpstorm` | +| `PyCharmProfessional` | `PY` | `com.jetbrains.intellij.pycharm:pycharmPY` | +| `PyCharmCommunity` | `PC` | `com.jetbrains.intellij.pycharm:pycharmPC` | +| `Rider` | `RD` | `com.jetbrains.intellij.rider:riderRD` | +| `RustRover` | `RR` | `com.jetbrains.intellij.rustrover:RustRover` | +| `Writerside` | `WRS` | `com.jetbrains.intellij.idea:writerside` | + + +## ProductInfo +{#ProductInfo} + +Represents information about the IntelliJ Platform product. + +The information is retrieved from the product-info.json file in the IntelliJ Platform directory. + +| Name | Description | +|-------------------|--------------------------------------------------------------------------| +| name | The product's name, like "IntelliJ IDEA". | +| version | The marketing version of the product, like "2023.2". | +| versionSuffix | The suffix of the version, like "EAP". | +| buildNumber | The build number of the product, like "232.8660.185". | +| productCode | The product code, like "IU". | +| dataDirectoryName | The directory name of the product data. | +| svgIconPath | The path to the SVG icon of the product. | +| productVendor | The vendor of the product. | +| launch | The list of OS- and arch-specific launch configurations for the product. | +| customProperties | The list of custom properties of the product. | +| bundledPlugins | The list of bundled plugins provided with the current release. | +| fileExtensions | The list of file extensions associated with the product. | +| modules | The list of modules of the product. | + +### validateSupportedVersion() +{#ProductInfo-validateSupportedVersion} + +Validates that the resolved IntelliJ Platform is supported by checking against the minimal supported IntelliJ Platform version. + +If the provided version is lower, an `IllegalArgumentException` is thrown with an appropriate message. + +{style="narrow"} +Throws +: `IllegalArgumentException` + + +## ProductRelease.Channel +{#ProductRelease-Channel} + +[`ProductRelease.Channel`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/model/ProductRelease.kt) + +List of available channels used by JetBrains IDEs and Android Studio for describing binary releases. + +| Name | JetBrains IDEs | Android Studio | +|-------------|:--------------:|:--------------:| +| `EAP` | X | | +| `MILESTONE` | | X | +| `BETA` | | X | +| `RELEASE` | X | X | +| `CANARY` | | X | +| `PATCH` | | X | +| `RC` | | X | +| `PREVIEW` | | X | + +See also: +- [Extension: `intellijPlatform.verifyPlugin.ides`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-ides) +- [Tasks: `printProductsReleases`](tools_intellij_platform_gradle_plugin_tasks.md#printProductsReleases) + + +## ProductReleasesValueSource.FilterParameters +{#ProductReleasesValueSource-FilterParameters} + +[`ProductReleasesValueSource.FilterParameters`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/provider/ProductReleasesValueSource.kt) + +Interface that provides a clear way to filter binary product releases for the purposes of IntelliJ Plugin Verifier. + +| Name | Description | +|--------------|------------------------------------------------------------------------------------------------------| +| `sinceBuild` | Build number from which the binary IDE releases will be matched. | +| `untilBuild` | Build number until which the binary IDE releases will be matched. | +| `types` | A list of [`IntelliJPlatformType`](#IntelliJPlatformType) types to match. | +| `channels` | A list of [`ProductRelease.Channel`](#ProductRelease-Channel) types of binary releases to search in. | + +See also: +- [Extension: `intellijPlatform.verifyPlugin.ides`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-ides) +- [Tasks: `printProductsReleases`](tools_intellij_platform_gradle_plugin_tasks.md#printProductsReleases) + + +## Subsystems +{#Subsystems} + +[`VerifyPluginTask.Subsystems`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginTask.kt) + +Specifies which subsystems of the IDE should be checked by the IntelliJ Plugin Verifier CLI tool run with the [`verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) task. + +| Name | Description | +|-------------------|----------------------------------------------| +| `ALL` | Verify all code. | +| `ANDROID_ONLY` | Verify only code related to Android support. | +| `WITHOUT_ANDROID` | Exclude problems related to Android support. | + +See also: +- [Extension: `intellijPlatform.verifyPlugin.subsystemsToCheck`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-subsystemsToCheck) +- [Tasks: `verifyPlugin.subsystemsToCheck`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-subsystemsToCheck) + + +## VerificationReportsFormats +{#VerificationReportsFormats} + +[`VerifyPluginTask.VerificationReportsFormats`](%gh-ijpgp%/src/main/kotlin/org/jetbrains/intellij/platform/gradle/tasks/VerifyPluginTask.kt) + +Enum class describing the type of the results produced by the IntelliJ Plugin Verifier CLI tool run with the [`verifyPlugin`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin) task. + +| Name | Description | +|------------|--------------------------------| +| `PLAIN` | Plain text file. | +| `HTML` | HTML formatted output file. | +| `MARKDOWN` | Markdown file. | +| `ALL` | Contains all possible options. | +| `NONE` | Contains no option. | + +See also: +- [Extension: `intellijPlatform.verifyPlugin.verificationReportsFormats`](tools_intellij_platform_gradle_plugin_extension.md#intellijPlatform-verifyPlugin-verificationReportsFormats) +- [Tasks: `verifyPlugin.verificationReportsFormats`](tools_intellij_platform_gradle_plugin_tasks.md#verifyPlugin-verificationReportsFormats) + + + diff --git a/v.list b/v.list index a8b64586a..0e132df38 100644 --- a/v.list +++ b/v.list @@ -19,6 +19,9 @@ + + +