hxuanyu/intellij-sdk-code-samples
1
0
Fork 0
mirror of https://github.com/JetBrains/intellij-sdk-code-samples.git synced 2025-07-28 01:07:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

add <path> marker for files, paths and extensions

Browse Source
This commit is contained in:
Karol Lewandowski 2022-02-28 12:03:36 +01:00
parent 4c4a3cc371
commit bf0e8dfdb0
26 changed files with 65 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
topics/basics/indexing_and_psi_stubs/file_based_indexes.md
View File

@ -25,7 +25,7 @@ When accessing an index, specify the key you're interested in and get back the l
## Implementing a File-Based Index
> A relatively simple file-based index implementation is the [UI Designer bound forms index](upsource:///plugins/ui-designer/src/com/intellij/uiDesigner/binding/FormClassIndex.java), storing FQN of bound implementation class for [GUI Designer](https://www.jetbrains.com/help/idea/gui-designer-basics.html) `.form` files.
> A relatively simple file-based index implementation is the [UI Designer bound forms index](upsource:///plugins/ui-designer/src/com/intellij/uiDesigner/binding/FormClassIndex.java), storing FQN of bound implementation class for [GUI Designer](https://www.jetbrains.com/help/idea/gui-designer-basics.html) <path>.form</path> files.
>
{type="tip"}

2
topics/basics/indexing_and_psi_stubs/stub_indexes.md
View File

@ -25,7 +25,7 @@ You usually don't need to have stubs for things like statements or local variabl
The following steps need to be performed only once for each language that supports stubs:
* Change the file element type for your language (the element type that you return from `ParserDefinition.getFileNodeType()`) to a class that extends [`IStubFileElementType`](upsource:///platform/core-impl/src/com/intellij/psi/tree/IStubFileElementType.java).
* In your `plugin.xml`, define the `com.intellij.stubElementTypeHolder` extension and specify the interface which contains the `IElementType` constants used by your language's parser as well as `externalIdPrefix` if possible ([example](upsource:///plugins/properties/src/META-INF/plugin.xml)).
* In your <path>plugin.xml</path>, define the `com.intellij.stubElementTypeHolder` extension and specify the interface which contains the `IElementType` constants used by your language's parser as well as `externalIdPrefix` if possible ([example](upsource:///plugins/properties/src/META-INF/plugin.xml)).
For each element type that you want to store in the stub tree, you need to perform the following steps:

2
topics/basics/persisting_state_of_components.md
View File

@ -134,7 +134,7 @@ It has the following fields:
The simplest ways of specifying the `@Storage` annotation are as follows:
* `@Storage("yourName.xml")` If a component is project-level — for `.ipr` based projects standard project file is used automatically - no need to specify anything.
* `@Storage("yourName.xml")` If a component is project-level — for <path>.ipr</path> based projects standard project file is used automatically - no need to specify anything.
* `@Storage(StoragePathMacros.WORKSPACE_FILE)` for values stored in the workspace file.

6
topics/basics/project_structure.md
View File

@ -30,9 +30,9 @@ A module can depend on other modules of the project.
### Library
A _library_ is an archive of compiled code (such as JAR files) on which modules depend.
The IntelliJ Platform supports three types of libraries:
* **Module Library**: the library classes are visible only in this module, and the library information is recorded in the module's `.iml` file.
* **Project Library**: the library classes are visible within the project, and the library information is recorded in the project's `.ipr` file or in `.idea/libraries`.
* **Global Library**: the library information is recorded in the `applicationLibraries.xml` file in the `~/.IntelliJIdea/config/options` directory.
* **Module Library**: the library classes are visible only in this module, and the library information is recorded in the module's <path>.iml</path> file.
* **Project Library**: the library classes are visible within the project, and the library information is recorded in the project's <path>.ipr</path> file or in <path>.idea/libraries</path>.
* **Global Library**: the library information is recorded in the <path>applicationLibraries.xml</path> file in the <path>~/.IntelliJIdea/config/options</path> directory.
Global libraries are similar to project libraries but are visible for different projects.
For more information about libraries, refer to [Library](https://www.jetbrains.com/help/idea/working-with-libraries.html).

2
topics/basics/run_configurations/run_configuration_management.md
View File

@ -88,7 +88,7 @@ If it is, you return a [`RefactoringElementListener`](upsource:///platform/analy
## Creating Configurations from Context
Many plugins support automatic creation of run configurations from context so that the user can click, for example, on an application or test class and automatically run it using the correct run configuration type.
To support that, you need to provide an implementation of the [`RunConfigurationProducer`](upsource:///platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java) interface and to register it as `<runConfigurationProducer>` in your `plugin.xml`.
To support that, you need to provide an implementation of the [`RunConfigurationProducer`](upsource:///platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java) interface and to register it as `<runConfigurationProducer>` in your <path>plugin.xml</path>.
This API was redesigned in IntelliJ IDEA 13; the previous [`RuntimeConfigurationProducer`](upsource:///platform/lang-api/src/com/intellij/execution/junit/RuntimeConfigurationProducer.java) is a much more confusing version of the same API.
The two main methods that you need to implement are:

4
topics/intro/sdk_style.md
View File

@ -77,7 +77,7 @@ General Markdown links have the default Markdown link style:
If URL contains `%` character, append `{interpolate-variables="false"}`.
* Linking to pages within the SDK documentation:
`[Page Title](page.md)`{disable-links} links to an SDK doc page (all located under <path>/topics</path>).
Note that the extension is `.md`, _NOT_ `.html`.
Note that the extension is <path>.md</path>, _NOT_ <path>.html</path>.
* Linking to specific _sections_ on pages in the SDK documentation.
The anchor name will be all lower case, and spaces are replaced with `-`, e.g. `## Page setup` becomes `#page-setup`.
Once the anchor (`#`) character of the link is entered, the IDE code completion feature shows the available sections.
@ -257,7 +257,7 @@ A placeholder is useful to keep track of what should be documented, but hasn't y
When renaming pages, redirects should be configured so existing links and bookmarks continue working.
Specify the previous path(s) with `.html` extension in `accepts-web-file-names` attribute:
Specify the previous path(s) with <path>.html</path> extension in `accepts-web-file-names` attribute:
```xml
<toc-element id="fundamentals.md" toc-title="Fundamentals"

2
topics/products/idea/spring_api.md
View File

@ -153,7 +153,7 @@ Add additional inspections (e.g. for custom namespace) to Spring Validator (*Set
#### Add Additional Files to Spring Validator
_Version 14.1_
Additional files to be processed by inspections registered with Spring Validator (e.g. specific `.properties` configuration files) can be registered via `com.intellij.spring.SpringInspectionsRegistry$AdditionalFilesContributor`
Additional files to be processed by inspections registered with Spring Validator (e.g. specific <path>.properties</path> configuration files) can be registered via `com.intellij.spring.SpringInspectionsRegistry$AdditionalFilesContributor`
#### Configure Spring Support for Other Frameworks
Use `com.intellij.spring.facet.SpringConfigurator` to provide "automatic" configuration when Spring facet is added via framework wizard.

24
topics/reference_guide/color_scheme_management.md
View File

@ -9,7 +9,7 @@ Previously language plug-ins were using fixed default colors incompatible, for e
The new implementation allows specifying a dependency on a set of standard text attributes linked to a scheme but not to any specific language.
Language-specific attributes still can be set by a scheme designer if needed, but it's optional.
New color schemes have got a new `.icls` (Idea CoLor Scheme) extension to avoid confusion about compatibility problems with older platform versions:
New color schemes have got a new <path>.icls</path> (Idea CoLor Scheme) extension to avoid confusion about compatibility problems with older platform versions:
if only standard attributes are set, they will not be used by the version before 12.1, resulting in different highlighting colors.
## Plug-in Developers
@ -41,14 +41,14 @@ The rule is the same: if text attributes can not be found by the `MY_PREDEFINED_
{type="note"}
If you are unsure which base key to use, it's better to pick the most generic one, for example, `DefaultLanguageHighlighterColors.IDENTIFIER`.
Remember that using fixed default attributes *will force* a scheme designer to explicitly set up a color for this element.
Remember that using fixed default attributes *will force* a scheme designer to explicitly set up a color for this element.
Otherwise, its default colors may visually conflict with a color scheme.
If the scheme designer doesn't have a language plug-in, he will not be able to fix this at all.
### Providing Attributes for Specific Schemes
A language plug-in may provide default text attributes for "Default" and "Darcula" bundled schemes or basically for any other scheme if the scheme's name is known.
This can be done in `plugin.xml` by adding an `com.intellij.additionalTextAttributes` extension providing the name of the file containing desired text attributes, for example:
This can be done in <path>plugin.xml</path> by adding an `com.intellij.additionalTextAttributes` extension providing the name of the file containing desired text attributes, for example:
```xml
<extensions defaultExtensionNs="com.intellij">
@ -58,8 +58,8 @@ This can be done in `plugin.xml` by adding an `com.intellij.additionalTextAttrib
</extensions>
```
It tells the IDE that the file `MyLangDefault.xml` must be searched in resources under `colorSchemes`.
Note that the path should *not* start with a backslash and its fully qualified name (in our case `colorSchemes/MyLangDefault.xml`) *MUST BE UNIQUE* to avoid naming collisions between different providers.
It tells the IDE that the file <path>MyLangDefault.xml</path> must be searched in resources under <path>colorSchemes</path>.
Note that the path should *not* start with a backslash and its fully qualified name (in our case <path>colorSchemes/MyLangDefault.xml</path>) *MUST BE UNIQUE* to avoid naming collisions between different providers.
Thus adding a language prefix, for example, "MyLang", is highly recommended.
The file itself is an extract from a color scheme with required attributes, for example:
@ -82,8 +82,8 @@ The file itself is an extract from a color scheme with required attributes, for
</list>
```
*Note:* When the scheme is copied via "Save as..." all its attributes, including the ones defined in the extension, will be copied to the new scheme.
A scheme designer may need to check that these copied attributes do not conflict with his/her color scheme, although in this case the plug-in is installed, and it should not cause any problems.
*Note:* When the scheme is copied via "Save as..." all its attributes, including the ones defined in the extension, will be copied to the new scheme.
A scheme designer may need to check that these copied attributes do not conflict with his/her color scheme, although in this case, the plug-in is installed, and it should not cause any problems.
Anyway, try to stick with a simple key dependency if possible (note that it works well for "Darcula") and provide explicit attributes only if necessary.
## Scheme Designers
@ -91,10 +91,10 @@ Anyway, try to stick with a simple key dependency if possible (note that it work
### A Typical Workflow for a New Scheme Creation
* Choose a scheme which will be used as a base, for example, "Default"
* Click "Save As.." and give a name for the new scheme
* First set attributes in *General* section and proceed with *Language Defaults*
* Click "Save As..." and give a name for the new scheme
* First set attributes in the *General* section and proceed with *Language Defaults*
* Check all the languages and adjust language-specific text attributes if necessary.
In most cases this may not be needed, but two cases may require an extra action:
In most cases, this may not be needed, but two cases may require an extra action:
* There is an obsolete plug-in which does not use the new color scheme management API and therefore does not utilize the attributes set in "Language Defaults".
Ideally, a report must be created for the language plug-in so that its author will fix it eventually.
@ -105,6 +105,6 @@ Anyway, try to stick with a simple key dependency if possible (note that it work
### Text Attributes Inheritance
For many language text attributes that do not have any values, there will be a line indicating that the attributes are inherited from a specific section/attributes, such as "Keyword (Language Defaults)".
If an element has *any* attributes set, only these attributes are used.
If an element has *any* attributes set, only these attributes are used.
All attributes from the base element are ignored.
To *restore* the inheritance, unchecks all the boxes, and click *Apply*.
To *restore* the inheritance, unchecks all the boxes, and click *Apply*.

10
topics/reference_guide/frameworks_and_external_apis/external_builder_api.md
View File

@ -45,8 +45,8 @@ To pass custom data between the invocation of the same builder between multiple
The external builder process uses the standard Java [services](https://docs.oracle.com/javase/8/docs/api/java/util/ServiceLoader.html) mechanism to support plugins.
There are several service interfaces (e.g. [`BuilderService`](upsource:///jps/jps-builders/src/org/jetbrains/jps/incremental/BuilderService.java) which can be implemented in plugins to extend the builder functionality.
An implementation of a service needs to be registered by creating the `META-INF/services/<service-interface-fqn>` file containing the implementation class's qualified name.
E.g. `BuilderService` implementations are registered in `META-INF/services/org.jetbrains.jps.incremental.BuilderService` file.
An implementation of a service needs to be registered by creating the <path>META-INF/services/$service-interface-fqn$</path> file containing the implementation class's qualified name.
E.g. `BuilderService` implementations are registered in <path>META-INF/services/org.jetbrains.jps.incremental.BuilderService</path> file.
These files don't have extensions, so you need to map corresponding patterns to text files in IDE settings.
### Registering a Plugin for External Builder
@ -108,11 +108,11 @@ The log file is located under the directory:
<ide-system-directory>/log/build-log
```
There, both `build-log.log` and `build-log.properties` files can be found.
The `build-log.properties` is a log4j configuration file, where the log level and desired logging categories can be adjusted.
There, both <path>build-log.log</path> and <path>build-log.properties</path> files can be found.
The <path>build-log.properties</path> is a log4j configuration file, where the log level and desired logging categories can be adjusted.
This file contains logging from all build sessions, including those from the auto-make.
In IntelliJ Platform versions before version 14.1, log4j configuration was stored in `build-log.xml`.
In IntelliJ Platform versions before version 14.1, log4j configuration was stored in <path>build-log.xml</path>.
### Accessing Project Model and Configuration from External Build

2
topics/reference_guide/frameworks_and_external_apis/external_system_integration.md
View File

@ -6,7 +6,7 @@ This page provides a high-level overview of the *External System* sub-system.
There are multiple project management systems ([Apache Maven](https://maven.apache.org/), [Gradle](https://www.gradle.org/), [sbt](https://www.scala-sbt.org/), etc.) and IntelliJ Platform provides a mechanism to support them in IDEs.
Most of the project management systems provide a similar set of facilities from the integration point of view:
* build a project from external system config (`pom.xml`, `build.gradle`, etc.)
* build a project from external system config (<path>pom.xml</path>, <path>build.gradle</path>, etc.)
* provide a list of available tasks
* allow to execute a particular task
* and more

10
topics/reference_guide/intellij_artifacts.md
View File

@ -17,22 +17,22 @@ See the [Maven coordinates](#specify-the-maven-coordinates-for-the-artifact) sec
Both the Releases and Snapshots repositories have two types of content:
* Binary and source code artifacts for cross-platform, ZIP distributions of IntelliJ Platform-based IDEs, such as IntelliJ IDEA, CLion, Rider, and MPS.
These artifacts are _not intended_ to be accessed directly from a plugin project's `build.gradle` file.
These artifacts are _not intended_ to be accessed directly from a plugin project's <path>build.gradle</path> file.
The `gradle-intellij-plugin` will access them as-needed for a plugin project.
* Artifacts for individual modules from the IntelliJ Platform.
These may be downloaded, or accessed directly from a `build.gradle` file, as explained below.
These may be downloaded, or accessed directly from a <path>build.gradle</path> file, as explained below.
### Third-Party Dependencies
Artifacts for IntelliJ Platform third-party dependencies are hosted at a separate [intellij-dependencies](https://cache-redirector.jetbrains.com/intellij-dependencies) repository.
A link to this repository should be added to `pom.xml`/`build.gradle` files when individual modules from an IntelliJ Platform artifacts repository are used.
A link to this repository should be added to <path>pom.xml</path>/<path>build.gradle</path> files when individual modules from an IntelliJ Platform artifacts repository are used.
> Usages of deprecated URL `https://jetbrains.bintray.com/intellij-third-party-dependencies` must be replaced with `https://cache-redirector.jetbrains.com/intellij-dependencies` in build scripts.
>
{type="warning"}
## Using IntelliJ Platform Module Artifacts
IntelliJ Platform module artifacts are utilized by adding information to a project's `build.gradle` file.
IntelliJ Platform module artifacts are utilized by adding information to a project's <path>build.gradle</path> file.
More information about [Gradle support](https://www.jetbrains.com/help/idea/gradle.html) is available in the IntelliJ IDEA Help documentation.
To setup dependencies on a module there are two types of information needed:
@ -89,7 +89,7 @@ For example, to specify the `jps-model-serialization` module:
* _packaging_ = `jar`
## Gradle Example for an Individual Module from the IntelliJ Platform
This section presents an example of using a Gradle script to incorporate an IntelliJ Platform module and repository in a `build.gradle` file.
This section presents an example of using a Gradle script to incorporate an IntelliJ Platform module and repository in a <path>build.gradle</path> file.
The example illustrates declaring the artifact URL, Maven coordinates, and version for the `jps-model-serialization` module artifact.
There are two parts to the example: the repository and the dependency sections.

6
topics/reference_guide/project_model/library.md
View File

@ -5,9 +5,9 @@
A library is an archive of compiled code (such as JAR files) that modules depend on.
The IntelliJ Platform supports three types of libraries:
* **Module Library**: the library classes are visible only in this module and the library information is recorded in the module `.iml` file.
* **Project Library**: the library classes are visible within the project and the library information is recorded under `.idea/libraries` directory or in the project `.ipr` file.
* **Global Library**: the library information is recorded in the `applicationLibraries.xml` file in `<User Home>/.IntelliJIdea/config/options` directory. Global libraries are similar to project libraries, but are visible for different projects.
* **Module Library**: the library classes are visible only in this module and the library information is recorded in the module <path>.iml</path> file.
* **Project Library**: the library classes are visible within the project and the library information is recorded under `.idea/libraries` directory or in the project <path>.ipr</path> file.
* **Global Library**: the library information is recorded in the <path>applicationLibraries.xml</path> file in <path>$USER_HOME$/.IntelliJIdea/config/options</path> directory. Global libraries are similar to project libraries, but are visible for different projects.
For more information about libraries, refer to [Libraries](https://www.jetbrains.com/help/idea/working-with-libraries.html).

10
topics/reference_guide/project_model/project.md
View File

@ -7,13 +7,13 @@
The IntelliJ Platform stores the project configuration data in XML files.
The list of those files depends on the chosen [project format](https://www.jetbrains.com/help/idea/creating-and-managing-projects.html#project-formats).
For file-based format projects (legacy), the information core to the project itself (e.g., location of the component modules, compiler settings, etc.) is stored in the `$project_name$.ipr` file.
The information about modules the project includes is stored in `$module_name$.iml` files.
For file-based format projects (legacy), the information core to the project itself (e.g., location of the component modules, compiler settings, etc.) is stored in the <path>$project_name$.ipr</path> file.
The information about modules the project includes is stored in <path>$module_name$.iml</path> files.
Module files are created for each module.
For directory-based format projects, the project and workspace settings are stored in a number of XML files under the `$project_home_directory$/.idea` directory.
Each XML file is responsible for its own set of settings and can be recognized by its name: `projectCodeStyle.xml`, `encodings.xml`, `vcs.xml` etc.
As for the file-based format projects, `.iml` files describe modules.
For directory-based format projects, the project and workspace settings are stored in a number of XML files under the <path>$project_home_directory$/.idea</path> directory.
Each XML file is responsible for its own set of settings and can be recognized by its name: <path>projectCodeStyle.xml</path>, <path>encodings.xml</path>, <path>vcs.xml</path> etc.
As for the file-based format projects, <path>.iml</path> files describe modules.
Note that direct access to project files isn't required to load or save settings.
See [Persisting State of Components](persisting_state_of_components.md) for more information.

2
topics/reference_guide/settings_guide.md
View File

@ -12,7 +12,7 @@ Settings can [affect different levels](https://www.jetbrains.com/help/idea/confi
This document describes adding custom Settings at the Project and Application (or Global, IDE) levels.
## Extension Points for Settings
Custom Settings implementations are declared in a plugin's configuration (`plugin.xml`) file using one of two Extension Points (EPs), depending on the level of the Settings.
Custom Settings implementations are declared in a plugin's configuration (<path>plugin.xml</path>) file using one of two Extension Points (EPs), depending on the level of the Settings.
Many [attributes](#settings-declaration-attributes) are shared between the EP declarations.
Application and Project Settings typically provide an implementation based on the [`Configurable`](upsource:///platform/ide-core/src/com/intellij/openapi/options/Configurable.java) interface because they do not have runtime dependencies.

4
topics/reference_guide/ui_themes/themes_metadata.md
View File

@ -157,8 +157,8 @@ Examples of Swing keys:
{type="note"}
Metadata is split up as follows:
- <path>[IntelliJPlatform.themeMetadata.json`](upsource:///platform/platform-resources/src/themes/metadata/IntelliJPlatform.themeMetadata.json)</path> - all keys from IntelliJ Platform and custom UI components
- <path>[JDK.themeMetadata.json`](upsource:///platform/platform-resources/src/themes/metadata/JDK.themeMetadata.json)</path> - all keys from Swing components
- [`IntelliJPlatform.themeMetadata.json`](upsource:///platform/platform-resources/src/themes/metadata/IntelliJPlatform.themeMetadata.json) - all keys from IntelliJ Platform and custom UI components
- [`JDK.themeMetadata.json`](upsource:///platform/platform-resources/src/themes/metadata/JDK.themeMetadata.json) - all keys from Swing components
New keys should be added to <path>IntelliJPlatform.themeMetadata.json</path> only (or corresponding "local" <path>*.themeMetadata.json</path> file of the plugin if applicable).

2
topics/reference_guide/work_with_icons_and_images.md
View File

@ -133,7 +133,7 @@ If the icon graphics are simple enough so that it renders perfectly in every sca
>
{type="note"}
All icon files must be placed in the same directory following this naming pattern (replace `.png` with `.svg` for SVG icons):
All icon files must be placed in the same directory following this naming pattern (replace <path>.png</path> with <path>.svg</path> for SVG icons):
* <path>iconName.png</path> W x H pixels (Will be used on non-Retina devices with default theme)
* <path>iconName@2x.png</path> 2\*W x 2\*H pixels (Will be used on Retina devices with default theme)

2
topics/tutorials/action_system/working_with_custom_actions.md
View File

@ -76,7 +76,7 @@ The fields of the form are:
In this case, `PopupDialogAction` would be available in the **Tools** menu, it would be placed at the top, and would have no shortcuts.
After finishing the **New Action** form and applying the changes, the `<actions>` section of the plugin's `plugins.xml` file would contain:
After finishing the **New Action** form and applying the changes, the `<actions>` section of the plugin's <path>plugins.xml</path> file would contain:
```xml
<actions>

4
topics/tutorials/custom_language_support/language_and_filetype.md
View File

@ -86,7 +86,7 @@ The `SimpleFileTypeFactory` is registered using the `com.intellij.openapi.fileTy
Run the plugin by using the Gradle [runIde task](gradle_prerequisites.md#running-a-simple-gradle-based-intellij-platform-plugin).
Create an empty file with the extension `*.simple`, and IntelliJ IDEA automatically associates it with our language.
Note the appearance of the Simple Language file icon next to the `test.simple` file in the **Project Tool Window**, and the editor tab for the file.
Create an empty file with the extension <path>.simple</path>, and IntelliJ IDEA automatically associates it with our language.
Note the appearance of the Simple Language file icon next to the <path>test.simple</path> file in the **Project Tool Window**, and the editor tab for the file.
![File Type Factory](file_type_factory.png){width="800"}

14
topics/tutorials/custom_language_support/lexer_and_parser_definition.md
View File

@ -10,14 +10,14 @@ The easiest way to create a lexer is to use [JFlex](https://jflex.de/).
**Reference**: [](implementing_lexer.md)
## Required Project Configuration Change
The previous tutorial step [Grammar and Parser](grammar_and_parser.md), and this page, generate source files in the directory `src/main/gen`.
To include those files, the project's `sourceSets` must be expanded by inserting the following line in the project's `build.gradle` file:
The previous tutorial step [Grammar and Parser](grammar_and_parser.md), and this page, generate source files in the directory <path>src/main/gen</path>.
To include those files, the project's `sourceSets` must be expanded by inserting the following line in the project's <path>build.gradle</path> file:
```groovy
sourceSets.main.java.srcDirs 'src/main/gen'
```
Or the following line in the project's `build.gradle.kts` file:
Or the following line in the project's <path>build.gradle.kts</path> file:
```kotlin
sourceSets["main"].java.srcDirs("src/main/gen")
```
@ -25,14 +25,14 @@ Or the following line in the project's `build.gradle.kts` file:
Reload the Gradle project for changes to take effect.
## Define a Lexer
Define a `Simple.flex` file with rules for the Simple Language lexer, as demonstrated in `org.intellij.sdk.language.Simple.flex`.
Define a <path>Simple.flex</path> file with rules for the Simple Language lexer, as demonstrated in `org.intellij.sdk.language.Simple.flex`.
```java
```
{src="simple_language_plugin/src/main/java/org/intellij/sdk/language/Simple.flex"}
## Generate a Lexer Class
Now generate a lexer class via **JFlex Generator** from the context menu on `Simple.flex` file.
Now generate a lexer class via **JFlex Generator** from the context menu on <path>Simple.flex</path> file.
The Grammar-Kit plugin uses the JFlex lexer generation.
When running for the first time, JFlex prompts for a destination folder to download the JFlex library and skeleton.
@ -71,7 +71,7 @@ The Simple Language parser is defined by subclassing [`ParserDefinition`](upsour
## Register the Parser Definition
Registering the parser definition in the <path>plugin.xml</path> file makes it available to the IntelliJ Platform.
Use the `com.intellij.lang.parserDefinition` extension point for registration.
For example, see `simple_language_plugin/src/main/resources/META-INF/plugin.xml`.
For example, see <path>simple_language_plugin/src/main/resources/META-INF/plugin.xml</path>.
```xml
<extensions defaultExtensionNs="com.intellij">
@ -84,7 +84,7 @@ For example, see `simple_language_plugin/src/main/resources/META-INF/plugin.xml`
Run the plugin by using the Gradle [runIde task](gradle_prerequisites.md#running-a-simple-gradle-based-intellij-platform-plugin).
Create a `test.simple` properties file with the following content:
Create a <path>test.simple</path> properties file with the following content:
```text
# You are reading the ".properties" entry.

2
topics/tutorials/custom_language_support/quick_fix.md
View File

@ -45,7 +45,7 @@ Choose "Create Property".
![Quick Fix](quick_fix.png){width="800"}
The IDE opens the `test.simple` file and adds `website.url` as a new key.
The IDE opens the <path>test.simple</path> file and adds `website.url` as a new key.
Add the new value `jetbrains.com` for the new `website.url` key.
![New Property](new_property.png)

2
topics/tutorials/custom_language_support/reference_contributor.md
View File

@ -92,7 +92,7 @@ public class SimpleElementFactory {
## Update Grammar and Regenerate the Parser
Now make corresponding changes to the `Simple.bnf` grammar file by replacing the `property` definition with the lines below.
Don't forget to regenerate the parser after updating the file!
Right-click on the `Simple.bnf` file and select **Generate Parser Code**.
Right-click on the <path>Simple.bnf</path> file and select **Generate Parser Code**.
```java
property ::= (KEY? SEPARATOR VALUE?) | KEY {

2
topics/tutorials/custom_language_support/structure_view_factory.md
View File

@ -48,7 +48,7 @@ The `SimpleStructureViewFactory` implementation is registered with the IntelliJ
## Run the Project
Run the project by using the Gradle [runIde task](gradle_prerequisites.md#running-a-simple-gradle-based-intellij-platform-plugin).
Open the `test.simple` file and choose **View \| Tool Windows \| Structure**.
Open the <path>test.simple</path> file and choose **View \| Tool Windows \| Structure**.
The IDE now supports a structure view of the Simple Language:
![Structure View](structure_view.png)

4
topics/tutorials/live_templates/template_support.md
View File

@ -30,7 +30,7 @@ There are many other [predefined functions](https://www.jetbrains.com/idea/help/
## Export the Live Template
Once the Live Template produces the expected result, [export the Live Template](https://www.jetbrains.com/help/idea/sharing-live-templates.html).
The export produces a file called `Markdown.xml` with the following contents:
The export produces a file called <path>Markdown.xml</path> with the following contents:
```xml
<templateSet group="Markdown">
@ -63,7 +63,7 @@ Ultimately, a file's extension determines the applicable Markdown context.
>
{type="note"}
Within the `<template>...</template>` elements in the `Markdown.xml` [Live Template definition file](#export-the-live-template), add the following context elements:
Within the `<template>...</template>` elements in the <path>Markdown.xml</path> [Live Template definition file](#export-the-live-template), add the following context elements:
```xml
<variable.../>

2
topics/tutorials/project_wizard/adding_new_steps.md
View File

@ -11,7 +11,7 @@ See [Creating a Plugin Project](gradle_build_system.md) to know how to do it.
## Register Module Builder
Project configuration settings depend on the project's module type.
Register a new `com.intellij.moduleBuilder` extension point in the `plugin.xml` configuration file.
Register a new `com.intellij.moduleBuilder` extension point in the <path>plugin.xml</path> configuration file.
```xml
<extensions defaultExtensionNs="com.intellij">

2
topics/tutorials/project_wizard/module_types.md
View File

@ -17,7 +17,7 @@ Create an empty plugin project, see [Creating a Plugin Project](gradle_build_sys
{type="note"}
## Register a New Module Type
Add a new `com.intellij.moduleType` implementation with the IntelliJ Platform in the `plugin.xml` configuration file.
Add a new `com.intellij.moduleType` implementation with the IntelliJ Platform in the <path>plugin.xml</path> configuration file.
```xml
<extensions defaultExtensionNs="com.intellij">