IntelliJ IDEA 2018 progress report: 2018.2 RC2 is out!
© Shutterstock /Vector Goddess
Time to check in on IntelliJ IDEA 2018! The second Release Candidate of IntelliJ IDEA 2018.2 is out, which can only mean one thing: 2018.2 is right around the corner.
No rest for the JetBrains team! The second Release Candidate of IntelliJ IDEA 2018.2 is here; it can be downloaded from the website, updated via Toolbox App, or you can just use patches for the in-product update if you’re using the previous RC build. according to the blog post announcing the news.
One more thing, though: You’ll need an active subscription to IntelliJ IDEA Ultimate, or, if you don’t have one, you can use a trial license.
RC2 comes with improvements in the MacBook Touch bar support such as a new Welcome dialog layout, the “Add configuration” button is now in the Run/Debug configuration dialog and more. Check out the release notes if you want to discover all the changes.
Update July 17, 2018
Now, IntelliJ IDEA clearly defines configured components, whether they are gateways, channels, bridges, etc. It doesn’t matter if these components were configured with XML or Java, the diagram shows them regardless.
2018.2 also provides a number of small but highly useful updates for Spring Boot. Developers can view the Spring dependencies in diagrams. Now, developers can do the same for the runtime dependencies of a Spring Boot application. Just start the application, go to the Endpoints tab, and enable “Diagram Mode” on the Beans tab.
There are a lot of beans to keep track of, so the Beans tab in Endpoints has a new feature to manage them. With the “Show Library Beans” button, developers can show or hide beans that do not belong to their code.
Additional features include the ability to run, edit, and test HTTP request mappings from Mappings in the Endpoint tab. Developers can also contribute new tabs under the Endpoints tab with the updated API.
Check the full changelog for all the updates and bugfixes for Spring and Spring Boot.
2018.1.6 is here!
One of the last stops before 2018.2 is finishing off all the updates and upgrades already in progress. 2018.1.6 is here, with a few good bug fixes.
- Fixed a throwable exception: unable to get stub builder: IDEA-181227.
- Fixed the issue that caused the go to Class/File/Symbol pop-ups to leak via the native window and focus traversal policy: IDEA-192184.
- Corrected the treatment of a Spring @Nullable annotation: IDEA-182842.
Check out the release notes for the complete list of fixes and improvements!
Updated July 11, 2018
2018.2 first release candidate ready to download
IntelliJ IDEA 2018.2 is just around the corner now that the first release candidate is here.
Here are some of the improvements that you’ll find in this release candidate:
- IntelliJ IDEA warns you about any blocking calls in lambdas within a reactive pipeline
- Multiple bug-fixes in the Spring Integration support.
- The Kotlin plugin bundled with the IDE has been updated to v1.2.51.
- The JDK was updated to version 1.8.0_152-release-1248-b89.
You can download it here.
You won’t find loads of major improvements but you’ll be happy to know that the first release candidate comes with some really great Spring Integration 5.x improvements, such as support for the Spring Integration annotations [@BridgeFrom and @BridgeTo annotations], and for the @EnablePublisher annotation.
The Reactor support has also been improved, which means that IntelliJ IDEA can now warn you about any blocking calls in lambdas within a reactive pipeline. They also fixed false positives in the Blocking operator call in non-blocking scope inspection, as well as some issues in the Run Dashboard, which now honors the ‘Single instance only’ flag of Run/Debug configuration dialog for Spring configuration [IDEA-188758] Remember the issue that caused the current run configuration to delete when pressing the Del key in the Search field of the Console tab of the Run Dashboard (*cough*IDEA-189873*cough*)? That’s also been fixed.
This announcement wouldn’t be complete without Kotlin so here it goes: the Kotlin plugin bundled with the IDE has been updated to v1.2.51. Speaking of updates, the JDK was updated to the version 1.8.0_152-release-1248-b89.
Updated July 2, 2018
IntelliJ IDEA 2018.2 beta
IntelliJ IDEA 2018.2 beta is here! The list is set for v2018.2; now it’s just time to polish the silver and check for any pesky bugs hiding around a corner. This preview has everything that’s on offer for 2018.2, so let’s take a closer look at what’s in store for developers!
Improved user interface
2018.2 comes with Mac Touch Bar support, making it easier for macOS developers to utilize the IDE from their own touch bar. Now, developers can run, build, and debug their projects in 2018.2 with the touch of a button.
These buttons are displayed in the app specific section of the Touch Bar interface. It should be noted that these buttons are dependent on context and which modifier keys are pressed. However, they are also highly customizable and cab be changed according to your preferences via the Touch Bar page in Preferences | Appearance & Behavior | Menus and Toolbars.
Other UI changes include a dark theme for Mac users as well as some brand new icons.
Additionally, the default visual setting for reassigned local variables and reassigned parameters is now underlined, to make it clearer to developers when things get moved around. This feature is available for both Java and Groovy.
Plus, when developers put a caret at the break or continue keyword, the IDE highlights the for or while keyword of the corresponding loop.
Java 11 should be on our doorsteps sometime in September. In the meantime, IntelliJ is making sure the IDEA 2018.2 is ready. This includes support for some upcoming JEPs, like local-variable syntax for lambda parameters. Find out more information about Java 11 in IntelliJ IDEA 2018.2 here.
In other news, developers can display known data flow information inside the editor with the Expression type action. Just type Ctrl+Shift+P twice and a small popup box appears with information about an actions type and nullability.
2018.2 can also display autompletions and Javadoc at the same time. As long as the Show the documentation info pop-up in… option is enable, both popups can appear in the editor at the same time. Check the settings at Preferences | Editor | General | Code Completion.
Along the same lines, 2018.2 displays type hints for long method chains. Sometimes, you need a little help to make sure the right type goes with the right method chain. That being said, the IDE hides the type hint for simple builders with obvious types.
Additionally, existing inspections have been updated as a result of Java 10 API changes. Keep an eye out for the loop to Stream API (and the reverse Stream to loop) changes for
New @Contract annotation return values
Want to use @Contract and specify a method reaction for when a particular parameter is passed? Developers tend to uses these annotations to get better warnings and remove false positives. There are now more return values for @Contract, including:
- new – returns a non-null new object when a method is executed
- this – the method returns non-null this reference
- paramX – the method returns its X-th argument
More information about @Contract annotation returns can be found here.
The JVM debugger has gotten a couple new improvements. For one, developers have breakpoint intention actions for debugging a Java project and don’t need to set up the properties by hand anymore. By pressing Alt+Enter, the IDE automatically offers developers new breakpoint intentions along with all other available intentions.
Additionally, developers can filter a breakpoint hit by the caller method. This allows developers to stop at a breakpoint if a certain conditional applies to the call stack.
Get the IntelliJ IDEA 2018.2 beta
Updated June 26, 2018
IntelliJ IDEA 2018.2: Data flow analysis
Want to figure out what bugs might be lurking in your code? Instead of laboriously searching for an error, IntelliJ IDEA 2018.2 brings improvements to data flow analysis and code simplification.
IntelliJ IDEA analyzes the data flow; if there are any suspicious bits of code, it’ll give the user a warning. Now, IntelliJ IDEA 2018.2 gives extra information about a particular symbol.
IntelliJ IDEA gives warnings in the editor if it detects suspicious code based on an analysis of data flow. In IntelliJ IDEA 2018.2 we can now see information known about a particular symbol. By typing Ctrl+Shift+P twice, it shows what kind of value this highlighted code might have.
While it works with many known values, the data flow analysis works best with array values. Now, IntelliJ IDEA shows the possible values from an array if it were statically initialized or if it was initialized as an empty collection. This kind of data flow analysis also supports more math operations like division and right shift.
Developers can also look inside streams with
Stream.of() to make sure that the downstream operations are logical, evaluating if this code can be simplified.
There is even increased support for evaluating simple methods, checking to see if certain conditions will always or never be true with Math or String methods. Methods supported on String are:
Methods supported on Math are:
More information can be found here.
Updated June 22, 2018
IntelliJ IDEA 2018.2 EAP 6
Developers will have better integration with Docker for IntelliJ IDEA 2018.2. With the “Context folder” feature, it is possible for developers to specify a base directory for executing a Docker run configuration. The Context folder is a new field in the Docker run configuration. It is set to a parent folder of whatever dockerfile is specified.
There are also a number of new runtime command line options:
- All the memory options
- The option to support –runtime=nvidia
Developers can also opt to use
--rm in Docker Run/Debug Configurations. This launches a temporary container that is cleaned up automatically upon termination.
The Use Soft Wraps action wraps the words in Docker logs for easier reading and clarity.
The File Watchers plugin has gotten a bit of an upgrade to reduce setup redundancy for multiple projects. File Watchers executes tasks on file modifications. Developer can now choose to do so on the project level or on the global level. This is not limited to once per-project, either!
Start getting ready for 2018.3
Search Everywhere is getting a total rewrite! You can start playing around with the new dialogue as Search Everywhere, Go to class, Go to file, Go to symbol, and Find action have been merged together. This is available in the experiential features option from the Maintenance dialog. Keep in mind that this is under active development, so objects may shift around during the flight.
IntelliJ IDEA EAP 5
Looking for a darker theme? If you want it darker, then Darcula has got it covered for the macOS. enable the Use dark window headers option to make the IntelliJ IDEA title bars even darker than before.
To improve comprehension and clarity, IntelliJ IDEA now highlights the corresponding loop of a for or while keyword when developers place a caret at the break or continue keywords.
Version Control Systems
Developers can now explore the repo state of any given revision using a new action, Browse Repository at Revision. This is available from the file history or from the VCS Log.
Additionally, the “unregistered roots detected” issue has been clarified. IntelliJ IDEA now registers the Git and Mercurial repositories automatically on the project opening as VSC roots.
EAP 5 and 6 come bundled with Kotlin v.1.2.50. This comes with support for runnable Kotlin scratch files and more.
For the full list of fixes, please check out the release notes.
Updated June 15, 2018
IntelliJ IDEA 2018.1.5
2018.1.5 has arrived for IntelliJ IDEA. This latest update brings a number of fixes for some pesky bugs as well as some solutions for a few unpleasant regressions. Here’s what developers can expect from this update.
As for bug fixes, developers should check out the release notes for the whole nine yards. Here are some of the big ones:
- The IDE can keep on track after using or canceling navigation pop-ups or menus (IDEA-191839)
- No more errors when navigating to class with Ctrl+N or cmd+O (IDEA-191860).
- Projects can store .iml externally without a compile fail (IDEA-191328).
- No more duplicate changelists if parts of the files are submitted to a Perforce changelist (IDEA-191521).
- Expressions can be evaluated in the lambda body now (IDEA-191797).
Updated May 30, 2018
The latest EAP for 2018.2 is here. With it comes improved support for @Contract annotations, breakpoint intentions in the JVM debugger, and Git integration for the version control system.
IntelliJ IDEA 2018.2 EAP3
IntelliJ IDEA already supports the @org.jetbrains.annotations.Contract annotation and has done so for a while. These annotations allow developers to specify a method reaction when a predetermined parameter is passed. In general, this is used for nullability analysis along with other inspections.
This latest update builds on previous improvements like automatic inference. Now, the Contract language supports more return values, making it easier for developers to use and giving them a better understanding of their methods results.
In particular, this update of the @Contract annotations makes it easier for developers to detect bugs in their code. IntelliJ IDEA even provides annotations from a Maven repo library for a quick fix for some detected problems.
Our last update (see below) went over the new breakpoint intentions available in IntelliJ IDEA 2018.2. Accessible by Alt+Enter, its new functionality includes filtering by a caller method.
Thanks to this new ability to filer breakpoints by the caller method, it’s possible to stop only when a certain condition applies to the call stack. Developers can also set a caller method filter by using the Caller filers field in the Breakpoint dialog.
Version control system
Git integration has been improved in 2018.2 with a useful new feature: the IDE autocompletes tags in the Checkout dialog. This little feature improves the user experience quite a bit, making it easier to find the right tag when you need it.
Download the latest version of IntelliJ IDEA 2018.2 here through the Early Access Program!
Updated May 23, 2018
IntelliJ IDEA 2018.1.4
First things first, let’s take a quick look at 2018.1.4. This is the fourth bugfix for the 2018 major version. Let’s take a look at some of the changes and bugfixes on offer.
Developers can now specify the directory to be used by the running application for each run configuration. This can be entered directly or with path variables.
IntelliJ IDEA 2018.1.4 supports Spring Boot 2’s relaxed binding rules for configuration keys.
Initially, $MODULE_DIR$ variable pointed to the directory containing .iml files. Projects imported from Gradle have the .iml file in the .idea directory. The .idea directory shouldn’t be used as a working directory for tests, due to test failures. So, now $MODULE_DIR$ points to the module’s content root, to avoid this scenario.
As a result, the $MODULE_DIR$ macro has been depreciated. There are two new macros:
- $MODULE_WORKING_DIR$ for module content directory.
- $MODULE_IML_DIR$ for directory containing the .iml file.
IntelliJ IDEA 2018.2 EAP2
The EAP for IntelliJ IDEA 2018.2 opened a week ago and there’s more to see with the EAP2! Specifically, more about the JVM debugger and the code refactoring feature.
The IntelliJ IDEA 2018.2 is going to bring new breakpoint intentions in the JVM debugger. Right now, you can limit the breakpoint to only hit particular object instances or define the class to be hit or not hit. However, this needed to be done by hand through a number of different filters and clicking o buttons.
The new JVM debugger offers a number of helpful intention actions, including
- Stop only in class
- Do not stop in class
- Stop only in the current object
Just press Alt+Enter during a debugging session and the IDE will offer you a bunch of new breakpoint intentions!
Additionally, IntelliJ IDEA 2018.2 offers a new preview panel for Extract Method refactoring. This should come in handy for performing refactoring on code fragments with duplicates.
Just use the shortcut Ctrl+Alt+M for the Extract Method dialog to preview all the changes in one place. Now, the IDE provides developers with the option to review the results of the refractoring… before it takes place!
Updated May 15, 2018
The IntelliJ IDEA 2018.2 Early Access Program is here! This release offers number of new features, including MacBook Touch Bar support, Gradle improvements, and more! Please see the changelog for the complete listing of updates.
MacBook Touch Bar
In particular, Mac users should be pretty happy with the upcoming support for the Touch Bar – this has been waiting in the wings for some time and it should ship with the 2018.2 general access release. However, if you want to try it, the EAP makes it possible for developers to run, build, and debug your project straight from the Touch Bar.
Impressively, the Touch Bar displays the contextually relevant controls for IntelliJ IDEA. The Touch Bar buttons can even be customized based on what actions you’d like to do. This includes using tools like Maven or Gradle, as well as configuring, debugging, and even committing a project. Additionally, the tool bar can even be modified under the Menus and Tool Bars tab under Appearance & Behavior.
This feature is quite new, so all feedback from you Mac users is heartily appreciated.
IntelliJ IDEA’s code completion tool is a work in progress, but 2018.2 EAP now shows autocomplete options and Javadoc at the same time. This feature needs to be enabled to try in the EAP. Another feature to make developer’s lives easier is the display option for known data flow right is inside the editor. To start, you need to invoke the Expression type action for the second time.
Additionally, there have been some downstream effects due to Java 10 API changes, including some code changes here and there for looping to stream API migration inspection and vice versa. Thanks to IDEA upgrades, the Stream API support has been improved for unsorted collections and Boolean expressions for more than three stream elements.
In the future, IntelliJ IDEA 2018.2 will support Java 11!
Developers can now debug a Gradle script in IntelliJ IDEA. The debugger can connect to the Gradle daemon. Also, the auto-discovery of an included buildSrc Gradle project now works.
Spring and Spring Boot
IntelliJ IDEA makes it easier to analyze complex Spring and Spring Boot projects with its own dedicated Spring diagrams. Developers can see these dependencies by using the Spring Beans or Spring Model Dependencies diagram. For runtime beans, developers can use the new Diagram Mode and see those dependencies.
The runtime feature for accessing HTTP request mappings from the editor has been upgraded. Developers can now manage the HTTP request mappings from Run Dashboard. This can be run straight away or opened in an editor-based REST client. There’s even an additional option to open HTTP requests in the browser for GET methods.
Version control systems, Maven, and more
- Version Control systems: Developers can invoke and resolve merge conflicts with the Resolve action; favorite branches added.
- Maven: improved support so the IDE works with the latest version of maven-compiler-plugin version 3.7.0.
- JSON: Now supports JSON scheme v4, v6, and v7
- Support for multiple GitHub Accounts
- Future releases of IDEA 2018 will come with the ability to specify the default directory for opening projects
- Kotlin 1.2.40 is bundled into IntelliJ IDEA 2018.2 EAP
- New icons!
Developers can download the first EAP build here. Feedback is welcome.
Update May 9. 2018
No longer just for early access, Intellij IDEA 2018.1.3 is now properly released and available for download. We already went over a lot of what’s in this release (see below), but let’s take a look at what else this stable update has to offer.
Probably the biggest thing we haven’t already covered is the update for the built-in JRE. Switching to 1.8.0_152-release-1136-b38 has a number of benefits, including:
- Bugfixes for a whole group of related issues for the broken Z-order of child windows JRE-692, JRE-695, JRE-705.
- It is now possible to disable IME via the JVM property: -Dawt.ime.disabled=true : JRE-729.
There has been a lot of work on improving performance for Spring, making it easier to open and update Spring diagrams.
Additionally, there was a lot of bugfixes for the search and replace. Now, the Find in Path shortcut is working again for the preview window.
Plus, users can turn on support screen readers with –Dide.support.screenreaders.enabled=true JVM option. Simple add a it to the idea.properties file before the first launch of a program.
Update April 27, 2018
Intellij IDEA 2018.1.3 EAP is now ready and available for download! What’s going on in this new release for the stable version? A whole lot of bugfixes, to be honest.
First off, IntelliJ IDEA 2018.1.3 EAP automatically checks for compatibility with your Kotlin plugin if you’re importing settings from previous versions. Additionally, if the imported Kotlin plugin isn’t comparable with this version, then it will use a bundled Kotlin version instead.
Other changes include support for very long names, especially in the Run/Debug configuration drop-down menu. No need to use abbreviations – IntelliJ IDEA 2018.1.3 supports 80 symbols by default.
IntelliJ IDEA also comes with improved Gradle support:
- Gradle projects that use composite builds can now succeed when the build action is delegated to Gradle: IDEA-190088.
- The navigation is fixed from the result in the Run/Debug view to the editor for JUnit5 test: IDEA-190103.
Finally, IntelliJ IDEA has also integrated a new JDK version. This comes with a few bugfixes of its own, including a possibility to disable IME via a JVM property, and an issue with IME window position of HiDPI screens.
Update April 13, 2018
IntelliJ IDEA 2018.1.1 is herere! This is the first bug-fix update for the recently released IntelliJ IDEA 2018.1. We’re fixing a lot of bugs in this release, from automatic updates to saving keystrokes.
The biggest problem on the docket: automatic updates. Initially, “automatically check for updates” was set to disabled by default (IDEA-189445). Now, you can make sure your version is up to date without needing to go to the settings.
IntelliJ IDEA 2018.1.1 now comes with support for annotationProcessorPaths option in the maven-compiler-plugin 3.5 for external dependencies. It also updated the bundled Kotlin plugin to v1.2.31
- Keystrokes are not lost during freezing (IDEA-186636)
- Clicking the Replace all option from the Replace in path dialog doesn’t cause the IDE to freeze (IDEA-188229)
- We’ve fixed the issue with broken JPS that inhibits all non-gradle Android builds (IDEA-189170)
- Facet settings stored externally are now loaded by the build process (IDEA-189112)
- Performance for scrolling huge text file on 4K monitors was improved (JRE-584)
- The issue with AWT popups, which were above other process windows after alt-tab, was fixed (JRE-695)
Update March 28, 2018
IntelliJ IDEA 2018.1 is JetBrains’ first major update of 2018. It brings a lot of improvements to supported languages, frameworks, version control tools, debugger, compiler, and editor.
We’re going to focus on some of the most important highlights presented in this blog post but if you want to see the full list of fixes, check out the release notes. Don’t forget to download IntelliJ IDEA 2018.1 from the JetBrains website or get the update from the Toolbox App.
What’s new in IntelliJ IDEA 2018.1
- Completion in the Stream API chains is now aware of type casting, which means it can suggest a completion item according to the existing call filter (String.class::isInstance), and also for an automatically typecast completion item.
- The data flow analysis can now track the relationships between variables like “greater than” and “less than.” Furthermore, the IDE also detects when a condition is always true (or false) in all the possible code paths when the variables are compared.
- The new Java 9 inspections and quick-fixes will come in handy because the IDE checks that a service loaded by ServiceLoader is declared in the module-info.java file, and offers a quick-fix to add a missing statement to the module-info.javafile.
- If there’s an unresolved class mentioned in module-info.java, the IDE will suggest creating the missing class, as well as missing exported packages.
- There’s a new Fix partially button which appears when you have several options for fixing possible problems in the chosen scope. You’ll find all the suggested quick-fixes grouped under the Fix partially button.
- Support for the JUnit5 @Tag annotation has been added, which means you can include tagged classes and tagged methods, in the testing scope. All you have to do is select the Tags (JUnit 5) option in the test kind field in the Run/Debug Configuration dialog. Make sure to use the Uniqueld field to filter tests according to their id.
- There’s a new Throw Exception action. This means you can throw an exception from a certain location in your program without changing the code. You’ll find it in the Run | Throw Exception menu, or in the frame context menu during a debugging session.
- You can now print breakpoints stack traces to the console — this option can be enabled in the Breakpoints dialog box.
- Furthermore, you can now copy the current thread stack trace via a new Copy Stack action.
- JetBrains has extended the Async stack traces feature, which means you can now use the @Async.Schedule and @Async.Execute annotations to set up capture points that are not included in the default configuration. All you have to do is add Maven artifact as a dependency.
- The new Use –release option for cross-compilation (Java 9 and later) checkbox on the Java Compiler page [you can find it here: Preferences | Build, Execution, Deployment | Compiler | Java Compiler] is enabled by default. You can, of course, disable it whenever you need to use the –source and –target options with Java 9 and link against Java 9 classes at the same time.
- You can use a specific version of the ECJ compiler. You’ll have to select Eclipse from the Use Compiler drop-down menu and specify the path to jar with the chosen compiler.
- Good news! If there are any issues that have been detected in your code, the IDE now highlights the folded code regions that contain errors or warnings, and colors such blocks according to their validation status.
- Speaking of folded code, the IDE also highlights folded code regions if they contain any matches when you search through the current file.
- You can now see the automatic inferences of @NotNull or @Nullable annotations right in your source code. You’ll have to enable the Show inferred annotations inline checkbox here: Preferences | Editor | General | Appearance.
- You’ll notice that, in the Project Tool Window, you can paste a code fragment directly into a package, and a new Kotlin file with the pasted code will be created.
- The Kotlin Plugin offers new intentions which convert the scoping function calls let and run into each other, as well as also into apply and vice versa.
- You can now annotate every groovy class in the scope with the @CompileStatic annotation [available in the context menu Refactor | Convert to @CompileStatic].
- IntelliJ IDEA 2018.1 also reports unnecessary import alias for Groovy files.
The changes from Android Studio 3.0 have been merged, which means there are a lot of new features, including:
- Android Profiler, a new suite of profiling tools that provide real-time data for your app’s CPU, memory, and network activity.
- Device File Explorer Tool Window shows the file and directory structure of your Android device or emulator. If you want to view, copy, and delete files on an Android device, this tool window will come in handy. You’ll find it in View | Tool Windows | Device File Explorer.
- The Layout Editor has been improved.
- You can now build Instant Apps – lightweight Android apps that can be run without installation. However, you’ll have to make sure the Instant Apps Development SDK is installed.
- After you run a Spring Boot web application, a new icon is shown in the gutter for methods with @RequestMapping annotations that handle incoming HTTP requests. If you want to open all the mappings in a scratch file with an .http extension and perform an HTTP request in the editor via the new REST client, go ahead and click the icon.
- All the beans that are registered in the application context can be seen in the Beans tab in the Run Dashboard (or in the Run Tool Window). In IntelliJ 2018.1, this information is also available in the editor.
- The latest TypeScript 2.7 features are now supported.
- The Implement Members action has been improved.
- You can create a new Vue project with the Vue.js plugin. To install Vue CLI, run npm install –g vue-cli in the terminal.
- The Docker plugin now supports Multiple Docker Compose files and respects not only a docker-compose.yml but also an optional docker-compose.override.yml file.
- The plugin shows all the existing Compose projects.
- The new Kubernetes plugin supports the Kubernetes resource files from v1.5 up to v1.9 [latest release]. It looks for the presence of apiVersion and other fields of this kind in the files, and if these are present, it will consider such files as Kubernetes resource files.
- Rich support for the YAML Kubernetes resource files: If you type the required key and invoke Smart Completion, the new plugin will auto-complete all the required keys from all the levels below.
- There’s a built-in Live Template that allows you to quickly create the type of YAML Kubernetes resource file that you need. There are a few predefined Kubernetes templates, and you can invoke the necessary Live Template by typing its abbreviation.
- Furthermore, the Kubernetes plugin will alert you whenever you select deprecated Kubernetes properties.
- There’s also some support for JSON Kubernetes resource files based on the JSON schema functionality