LivePlugin

Plugin for IntelliJ-based IDEs to create plugins at runtime using Kotlin and Groovy. To install search for "LivePlugin" in IDE Preferences -> Plugins -> Marketplace or use the "Install" button on the Plugin Marketplace website.

Why?

• Minimal setup — no need to set up a separate project for plugin development
• Fast feedback loop — plugins are (re)loaded in the same JVM instance as IDE without restart
• Usable IDE API — LivePlugin has a small API with entry points for common IDE APIs

Examples

Hello world (Groovy):

import static liveplugin.PluginUtil.show
show("Hello world") // Shows balloon notification popup with "Hello world" text

Insert New Line Above action (Kotlin):

import com.intellij.openapi.actionSystem.AnActionEvent
import liveplugin.*

// Action to insert a new line above the current line.
// Based on this post https://martinfowler.com/bliki/InternalReprogrammability.html
// Note that there is also built-in "Start New Line Before Current" action (ctrl+alt+enter).
registerAction(id = "Insert New Line Above", keyStroke = "ctrl alt shift ENTER") { event ->
    val project = event.project ?: return@registerAction
    val editor = event.editor ?: return@registerAction
    executeCommand(editor.document, project) { document ->
        val caretModel = editor.caretModel
        val lineStartOffset = document.getLineStartOffset(caretModel.logicalPosition.line)
        document.insertString(lineStartOffset, "\n")
        caretModel.moveToOffset(caretModel.offset + 1)
    }
}
show("Loaded 'Insert New Line Above' action<br/>Use 'ctrl+alt+shift+Enter' to run it")

Getting started

Make sure "hello world" works fine:

• In the Plugins tool window select "hello-world" plugin and click "Run" button to execute the plugin (Run Plugin action with ctrl+shift+L or alt+C, alt+E shortcut). It should display a message.
• Make a small modification in plugin.groovy/plugin.kts and rerun the plugin. On the second run, the previous version of the plugin will be unloaded before the code is evaluated again.
• Modify plugin.groovy/plugin.kts file again so that it fails to compile/run. You should see an error message in the Run tool window.
• Note that plugins are just folders with plugin.groovy or plugin.kts scripts as entry points. This means that you can, for example, copy the path to the plugin folder using the Copy Path action (ctrl/cmd+alt+C shortcut).

Try bundled examples:

• In the Plugins tool window click the "Plus" button (Add Plugin action) to add Kotlin or Groovy examples.
• It might be useful to install Kotlin or Groovy plugin if your IDE supports them.

Take a look at settings in the Plugins toowindow:

• Run Plugins on IDE Start — run all plugins on IDE start.
• Run Project Specific Plugins — run all plugins in .live-plugins project directory when the project is opened and unload them when the project is closed.
• Add LivePlugin and IDE Jars to Project — useful for Groovy plugins to get auto-completion and code navigation in plugin code. (Adding jars unrelated to your project is a bit of a hack but there seems to be no major problems with it.) Note that Kotlin plugins should have auto-completion and code navigation without it.

Learn more about IntelliJ API:

• Read (or at least skim) plugin development fundamentals.
• Explore IntelliJ source code by cloning it, browsing it on GitHub or in Upsource. One useful strategy is to search for text you can see in IDE UI and then figure out how it's connected to the code which does the actual work.
• PluginUtil class and liveplugin package might have some good starting points to explore IntelliJ API.

Once your plugin has grown, you can move it to a proper plugin project still using live plugin for reloading and maybe then convert it to become a dynamic plugin.

If something doesn't work or doesn't make sense, please feel free to ask in #plugin-live-plugin channel on Jetbrains platform slack or report an issue (it's ok to report an issue even if it's just a question).

How does LivePlugin work?

Overall, the idea is just to load and run plugin Groovy or Kotlin classes in the IDE JVM at runtime. More specifically the steps are:

• if there is an instance of pluginDisposable from previous execution, then dispose it (on EDT)
• create a new classloader with dependencies on other plugins and jars (on a background thread)
• compile code if necessary and load classes in the classloader (on a background thread)
• run the plugin code (on EDT)

This means that plugin code can use any internal IDE API and observe/change IDE state. There are some limitations of course, such as final fields and IDE APIs which are not designed to be re-initialized.

Most IntelliJ-based IDEs come with a bundled Groovy jar which is used for loading and running live plugins (otherwise, the groovy-all jar will be downloaded). LivePlugin uses its own version of Kotlin stdlib and compiler because the version bundled with IDEs changes quite often and seems to be harder to rely on.

Some practical use cases

• project-specific workflow automation
• integrating shell scripts with IDE
• prototyping plugins, experimenting with IntelliJ API

More examples

• intellij-emacs - macros for making IntelliJ more friendly to emacs users (see also blog post)
• Simplistic "compile and run haskell" action - this can also be done for other languages/environments
• Google quick search popup - prototype of google popup search mini-plugin
• Scripting a macros - example of finding and invoking built-in actions
• Console filter/transform example - example of filtering and changing console output
• VCS update listener example - example of adding callback on VCS update
• Find class dependencies - simple action to find all class dependencies within current project
• Module transitive dependencies - finds all transitive dependencies for modules in IDEA project
• Show text diff - really lame example of opening IntelliJ text diff window (please don't use it!)
• Find all recursive methods in project (for Java) - quick plugin as a follow-up for this talk
• Watching projects open/close events - an example of reloadable project listener
• Minimalistic view for java code - collapses most of Java keywords and types leaving only variable names
• Symbolize keywords - collapses Java keywords into shorter symbols
• Change List Size Watchdog - micro-plugin to show warning when change list size exceeds threshold (see also Limited WIP plugin)
• Template completion on "Tab" - simplistic prototype for auto-completion on tab key (in case built-in live templates are not enough)
• Completion contributor example - only gives an idea which part of IntelliJ API to use
• Google auto-completion contributor example - same as above but with Google search plugged in
• Add custom search example - only gives an idea which part of IntelliJ API to use
• Get files from last commits example - gets VirtualFiles from several last commits
• Show PSI view dialog - one-liner to show PSI viewer dialog. Normally it's only enabled in plugin projects.
• Simplistic "generify return type" - attempt to pattern-match PSI tree
• No copy-paste - disables copy/paste actions
• Text munging actions - simple actions on text (sort, unique, keep/delete lines)
• Wrap selection - micro-plugin to wrap long lines with separator
• Wrap selected text to column width - copy of this plugin https://github.com/abrookins/WrapToColumn
• Create .jar patch file for current change list - that's what it does
• Create .jar patch file for specified favorites list - similar to the above mini-plugin
• Remove getters/setters - removes all setters or getters in a class
• ISO DateTime / Epoch timestamp converter - converts Epoch time to/from ISO format
• Make cursor move in circle - definitely not practical but gives an idea about threading
• Word Cloud - shows world cloud for the selected item (file/package/folder)
• Project TreeMap View - shows project structure (packages/classes) as treemap based on size of classes
• Method History - combines built-in method history based on selection and method history based on method name
• Evaluate selection as Groovy - that's exactly what it does
• Taskbar Icon Changer - Changes the Windows Taskbar icon depending on the project name to provide a better overview when working with multiple projects
• Refocus Pinned Find Window - Shortcut to refocus the 'Find in Path' dialog with the Pin option enabled after selecting a result entry

Similar plugins

The idea of running code inside IntelliJ is not original. There are/were similar plugins:

• Flora - a similar plugin from JetBrains Hackathon
• IDE Scripting Console - experimental feature bundled since IntelliJ 14.1
• Script Monkey (out-of-date)
• PMIP - Poor Mans IDE Plugin (no longer available)
• Remote Groovy Console (out-of-date)
• Groovy Console Plugin (out-of-date)
• HotPlugin (out-of-date)

Contributing

Please see CONTRIBUTING.md.