Crea tu primer plugin para IntelliJ IDEA: aprende a personalizar tu IDE favorito

0
843

A estas alturas del «desarrollo de software» hemos pasado (y pasaremos) por muchas modas: etapas donde se nos recomiendan ciertos patrones o metodologías que pretenden incrementar nuestra eficacia y nuestra eficiencia. En función de nuestras necesidades profesionales y personales, algunas son bien recibidas, otras adaptadas, y otras desechadas.

Cuando «transpilamos» estas prácticas a nuestro día a día como programadores e intentamos aplicarlas a bajo nivel, al momento de la codificación, entra en juego un factor clave: la personalización. Cada persona es un mundo, su situación es única y así ha de reflejarse en la manera en la que esta codifica.

Trasladando este planteamiento a los editores de texto o a los IDEs («integrated development environment», o entorno de desarrollo integrado) nos damos cuenta de que tras el paso de los años, apoyándose en las propias comunidades de usuarios y haciendo un mínimo común múltiplo de sus necesidades, las organizaciones y compañías que hay detrás de estos editores nos ofrecen una serie de herramientas básicas que nos ayudan en nuestro desempeño. Es por ello que es importante aprender a usar todas las herramientas que estos IDEs nos ofrecen, ya que nos facilitan la vida en muchos aspectos y mejoran nuestra productividad, tal y como nos enseñó nuestro compañero César.

0. Índice de contenidos


  1. ¿Qué es un plugin?
  2. ¿Por qué crear un plugin?
  3. Entorno de trabajo
  4. Creación del proyecto
  5. UI
  6. Implementación del plugin
  7. Ejecución del plugin y comandos Gradle
  8. Instalación del plugin
  9. Conclusiones

1. ¿Qué es un plugin?


Tras hacer un poco de recopilación sobre la importancia de adaptar las herramientas de trabajo a nuestras necesidades, otro punto clave es la posibilidad de usar herramientas de terceros de manera integrada en nuestro IDE. Estos son conocidos como plugins o add-ons: extienden o amplían el entorno de desarrollo con nuevas funcionalidades, como por ejemplo integración con herramientas de control de versiones, de seguimiento de incidencias, asistentes de código, inspector de archivos, cambio de los estilos visuales del entorno de desarrollo, y un largo etcétera.

Estos plugins se pueden instalar bien manualmente, o bien a través de una herramienta tipo marketplace, la cual nos ofrece los plugins disponibles para el IDE de manera centralizada en un único sitio, y podremos instalarlos sin necesidad de ir a sitios de terceros.

1.1. Tipos de plugin

Existen una gran variedad de plugins, los cuales atienden a diferentes necesidades. Dichas necesidades pueden clasificarse y, por lo tanto, categorizarse. Según la documentación que nos ofrece JetBrains (ya que en este tutorial se va a crear un plugin para IntelliJ IDEA) podemos ver los siguientes tipos de plugins:

  • Custom language support: provee unas funcionalidades básicas para trabajar con un determinado lenguaje de programación, como por ejemplo formato de líneas de código, reconocimiento de tipo de archivo, análisis y auto completado de código, etc.
  • Framework integration: consiste tanto en características de reconocimiento de código avanzadas como en opciones para un framework de programación específico, lo cual ayuda a tener ayudas dentro del IDE para dicho framework.
  • Tool integration: posibilita la opción de integrar y manipular herramientas o componentes de terceros directamente desde el IDE sin la necesidad de cambiar de contexto.
  • User interface Add-ons: son los encargados de modificar la interfaz básica del propio IDE. Pueden ser nuevos componentes interactivos que proporcionan algún tipo de nueva funcionalidad, o simplemente modificaciones visuales.
  • Themes: estos plugins proporcionan a los diseñadores la posibilidad de personalizar la apariencia y el estilo de los propios componentes visuales del IDE.

2. ¿Por qué crear un plugin?


Como ya hemos comentado, existe una cantidad ingente de plugins ya creados que nos pueden hacer la vida más fácil. Entonces, ¿por qué embarcarse en esta campaña de crear un plugin?

Tal y como ocurre en el desarrollo de software, tener claras las necesidades y los aspectos a mejorar son clave a la hora de diseñar y crear una solución. Necesitamos que nuestro desarrollo aporte valor a nuestro equipo, a la comunidad, o a nosotros mismos. En función del ámbito en el que queramos desarrollar nuestro plugin, podemos intentar identificar esos huecos en los que aportar valor:

  • Desarrollo personal: ya que la forma de codificar de cada individuo es única, tal vez las soluciones disponibles sean demasiado genéricas y no se adapten a nuestras necesidades. Tal vez un plugin de inspección más personalizado pueda sernos útil a la hora de codificar, o un plugin de auto completado diseñado a nuestra medida. Puede que algún plugin de integración con terceros que nos aporte una solución específica a nuestras necesidades. Además de estos supuestos, también es una forma de hacer el IDE «nuestro», una extensión de nosotros, y poder aderezarlo a nuestro gusto nos va a generar una sensación de adherencia y comodidad extra.
  • Desarrollo para equipo/organización: altamente relacionado con el punto anterior si las prácticas que empleamos son extensibles a nuestro equipo e incluso a nuestra organización o compañía. Si, por ejemplo, nuestra organización trabaja con unas tecnologías en concreto y tenemos una serie de metodologías comunes, tal vez sería buena idea el desarrollo de algún plugin que las plasmara en nuestro desarrollo a más bajo nivel.
  • Desarrollo open source o para la comunidad: aquí las posibilidades pueden ser «infinitas». Puede que queramos publicar de manera abierta alguna de las funcionalidades creadas en alguno de los dos puntos anteriores, a modo de volcar en la comunidad ciertas herramientas para facilitar el trabajo de otros compañeros. O puede que queramos crear un plugin de integración con una herramienta novedosa la cual aún no tenga suficiente relevancia, pero que le pueda resultar útil a ciertos proyectos de código abierto. O desarrollar una versión abierta que ofrezca una funcionalidad que ofrecen otros plugins de pago.

3. Entorno de trabajo


Durante la creación de este tutorial se ha usado el siguiente entorno:

  • Hardware: Portátil MacBook Pro (16 pulgadas, 2021, Apple M1 Pro, 32 GB RAM)
  • Sistema Operativo: macOS Monterey 12.5.1
  • IntelliJ IDEA Ultimate 2023.1.2

4. Creación del proyecto


Entramos en materia. En este tutorial vamos a crear un plugin para IntelliJ IDEA, del ecosistema de JetBrains.

Para ello vamos a tomar como referencia la documentación oficial del IntelliJ Platform SDK. Vamos a realizar un plugin con varios componentes, intentando sintetizar lo que en esta documentación nos viene referido.

4.1. Creación del proyecto a través del wizard de IntelliJ IDEA

Para la creación de un plugin para IntelliJ IDEA necesitamos primero crear un nuevo proyecto. Para ello abrimos nuestro IDE y seleccionamos la opción de New Project:

Nuevo proyecto
Nuevo proyecto

Una vez en la interfaz de creación de proyecto (o wizard de creación), tenemos que buscar en el apartado izquierdo, el de generadores, la opción IDE Plugin (en mi caso estoy usando la versión Ultimate 2023.1.2 del IDE, si usáis versiones anteriores es muy probable que esta opción no aparezca directamente y esté bajo la configuración de un proyecto Gradle):

Creación de proyecto
Creación de proyecto

Como observamos, esta ventana de configuración de un nuevo proyecto no difiere muchas de otras creaciones de frameworks basados en la JVM.

Lo más importante en esta ventana de configuración (en cuando a creación de plugin) es el apartado Type:

Type
Type

En nuestro caso seleccionamos Plugin. Si por el contrario queremos crear un nuevo tema, marcaríamos la opción Theme.

Una vez introducidos los parámetros necesarios, como el nombre, artifact, etc, pulsamos en crear proyecto… et voilà, ya tenemos nuestro primer proyecto de plugin para IntelliJ IDEA.

4.2. Creación del proyecto a través del Template de plugins de GitHub

Además de poder crear un nuevo proyecto a través del wizard de IntelliJ, existe un repositorio en GitHub que nos permite crear un proyecto para nuestro plugin de manera más fácil. No vamos a entrar en detalle de este template, pero para poder usarlo en tan sencillo como pulsar el botón user este template y, tras elegir crear un nuevo repositorio, puedes descargarlo en local y tener un proyecto ya configurado, e incluso con una ventana, un listener, y un servicio de ejemplo.

4.3. Estructura del proyecto

Una vez creado el proyecto con el wizard de IntelliJ, la estructura que obtenemos es la siguiente:

Estructura de proyecto
Estructura de proyecto

Por defecto el proyecto es creado bajo el paraguas de Gradle, usando Kotlin como lenguaje.

De la estructura podemos resaltar:

  • build/ – directorio donde se generan las builds.
  • src/main/kotlin/ – fuentes de kotlin
  • src/main/resources – recursos. Dentro de esta carpeta encontramos dos recursos claves:
    • META-INF/plugin.xml – podemos definir este fichero de configuración como el «entry point» o manifiesto del plugin (lo explicaremos más adelante)
    • META-INF/pluginIcon.svg – el icono de nuestro plugin.

En cuanto a la configuración de Gradle, la estructura que genera el wizard es la siguiente:

plugins {
    id("java")
    id("org.jetbrains.intellij") version "1.13.3"
}

group = "com.example"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

// Configure Gradle IntelliJ Plugin
// Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html
intellij {
    version.set("2022.2.5")
    type.set("IC") // Target IDE Platform

    plugins.set(listOf(/* Plugin Dependencies */))
}

tasks {
    // Set the JVM compatibility versions
    withType {
        sourceCompatibility = "17"
        targetCompatibility = "17"
    }

    patchPluginXml {
        sinceBuild.set("222")
        untilBuild.set("232.*")
    }

    signPlugin {
        certificateChain.set(System.getenv("CERTIFICATE_CHAIN"))
        privateKey.set(System.getenv("PRIVATE_KEY"))
        password.set(System.getenv("PRIVATE_KEY_PASSWORD"))
    }

    publishPlugin {
        token.set(System.getenv("PUBLISH_TOKEN"))
    }
}

Como vemos, nos ha incluído ciertas tareas específicas del SDK de IntelliJ, como la firma del plugin, publicación en el Marketplace, o versionado.

4.4. Estructura del plugin.xml

Como hemos visto, el archivo plugin.xml es el punto de entrada o manifiesto de nuestro plugin. Contiene toda la información del plugin que posteriormente va a ser mostrada en distintos puntos (como el Marketplace de plugins). Además, en este archivo se configuran todas las extensiones, actions, listeners, etc. Podéis echar un ojo más detallado a la documentación del mismo.

El wizard nos ha creado el siguiente xml:

<!-- Plugin Configuration File. Read more: https://plugins.jetbrains.com/docs/intellij/plugin-configuration-file.html -->
<idea-plugin>
<!-- Unique identifier of the plugin. It should be FQN. It cannot be changed between the plugin versions. -->
<id>com.example.demo</id>

<!-- Public plugin name should be written in Title Case.
Guidelines: https://plugins.jetbrains.com/docs/marketplace/plugin-overview-page.html#plugin-name -->
<name>Demo</name>

<!-- A displayed Vendor name or Organization ID displayed on the Plugins Page. -->
<vendor email="support@yourcompany.com" url="https://www.yourcompany.com">YourCompany</vendor>

<!-- Description of the plugin displayed on the Plugin Page and IDE Plugin Manager.
Simple HTML elements (text formatting, paragraphs, and lists) can be added inside of <![CDATA[ ]]> tag.
Guidelines: https://plugins.jetbrains.com/docs/marketplace/plugin-overview-page.html#plugin-description -->
<description><![CDATA[
Enter short description for your plugin here.<br>
<em>most HTML tags may be used</em>
]]></description>

<!-- Product and plugin compatibility requirements.
Read more: https://plugins.jetbrains.com/docs/intellij/plugin-compatibility.html -->
<depends>com.intellij.modules.platform</depends>

<!-- Extension points defined by the plugin.
Read more: https://plugins.jetbrains.com/docs/intellij/plugin-extension-points.html -->
<extensions defaultExtensionNs="com.intellij">

</extensions>
</idea-plugin>

Destacamos los siguientes campos:

  • id – contiene un identificador único el cual no puede cambiar entre versiones.
  • name – el nombre público del plugin, que posteriormente será usado en diferentes puntos. Deberá estar escrito en Title Case.
  • vendor – información de la empresa, organización o persona encargada en el desarrollo del plugin. Esta información será mostrada en la página del plugin.
  • description – descripción del plugin.
  • depends – dependencias con módulos existentes. Si nuestro plugin, por ejemplo, es un inspector de código Java, deberíamos añadir el módulo de Java como dependencia. Por defecto añade una dependencia con el propio módulo de IntelliJ
  • extensions – añadiendo una extensión del propio módulo de IntelliJ es la manera más común de crear un plugin. En este campo también se puede configurar la manera en la que nuestro plugin puede ser usado por plugins de terceros.

Además de estos campos básicos, y como hemos dicho, en este fichero de configuración han de especificarse el resto de actions, listeners, services, etc, como veremos más adelante.

4.5. Java vs Kotlin para la creación del plugin

El SDK de IntelliJ usa por defecto Kotlin, pero como podemos ver en la documentación oficial a partir de la versión 2023.1 soporta tanto Kotlin como Java de manera directa.

Para añadir fuentes de Java habría que crear el siguiente directorio: $PLUGIN_DIR$/src/main/java

En este tutorial vamos a emplear Java en vez de Kotlin para mostrar que dicho cambio es soportado.

5. UI


Los componentes usados en IntelliJ son componentes personalizados de Swing.

Estos mismos componentes pueden ser usados a la hora de crear nuestro plugin, asegurando que este se vea y funcione acorde con el resto del IDE, y así reducir el tiempo de desarrollo en comparación a crear uno nuevo desde cero usando componentes básicos de Swing. Usando el comando Ctrl/Cmd+Alt y clicando con el botón izquierdo del ratón, accedemos a las propiedades del componente Swing, pudiendo así observar cómo está creado un componente y entender mejor el uso de los mismos.

Existe una lista de componentes básicos listos para usar. Para no hacer este tutorial muy extenso os dejamos aquí el recurso, y más adelante detallaremos un poco los componentes a usar.

6. Implementación del plugin


El plugin va a consistir en una herramienta de texto integrada en el propio IDE, no necesitando así herramientas externas para hacer anotaciones, y evitando escribir comentarios temporales en nuestro código que posteriormente puedan ser llevados por error a nuestro control de versiones.

Para ello crearemos una nueva extensión la cual alojará nuestro texto. Además, crearemos una acción para llevar código desde el editor hasta el plugin. Esta acción podrá ser activada una vez tengamos texto seleccionado en el editor, como veremos a continuación.

6.1. Implementación de una extensión

Primero vamos a implementar la extensión de nuestro plugin. Dicha extensión se encontrará ubicada en la parte inferior del IDE.

6.1.1. Configuración del plugin.xml

En nuestro archivo plugin.xml, debemos de añadir la siguiente configuración en el apartado extensions:

<extensions defaultExtensionNs="com.intellij">
    <toolWindow
            factoryClass="com.example.demo.DemoToolWindowFactory"
            id="DemoTool"
            anchor="bottom"
            icon="AllIcons.Nodes.TextArea"  />
</extensions>

De esta manera le estamos indicando:

  • Que el componente usado va a ser un ToolWindow.
  • factoryClass – el nombre de la clase que va a implementar la interfaz ToolWindowFactory usada para crear el contenido del ToolWindow.
  • id – el nombre que va a ser mostrado en el IDE.
  • anchor – el lugar de la pantalla en el que el plugin va a ser mostrado. En nuestro caso indicamos que las queremos en la parte inferior del IDE.
  • icon – el icono mostrado en el nombre del plugin. En nuestro caso vamos a usar los iconos que nos ofrece el propio SDK de IntelliJ.

6.1.2. Creación de las clases e implementación del código

Una vez configurada la extensión en el xml de configuración, procedemos a implementar el ToolWIndowFactory:

package com.example.demo;

import com.intellij.openapi.project.Project;
import com.intellij.openapi.wm.ToolWindow;
import com.intellij.openapi.wm.ToolWindowFactory;
import com.intellij.ui.content.Content;
import com.intellij.ui.content.ContentFactory;
import org.jetbrains.annotations.NotNull;

public class DemoToolWindowFactory implements ToolWindowFactory {

    @Override
    public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
        DemoToolWindow window = new DemoToolWindow();
        ContentFactory contentFactory = ContentFactory.getInstance();
        Content content = contentFactory.createContent(window.getContent(), "", false);
        toolWindow.getContentManager().addContent(content);
    }

}

En este ejemplo, sobreescribimos el método createToolWindowContent. Dentro del método creamos una nueva ventana window (la cual implementaremos en el siguiente paso) la que será encargada de renderizar en su interior los componentes Swing usados para la escritura. Después de eso, obtenemos el contenido de nuestra ventada y lo añadimos al manager del toolWindow.

El siguiente paso es crear esa clase DemoToolWindow que hemos visto antes y que es la que implementa los componentes Swing pintados dentro de nuestra extensión:

package com.example.demo;

import com.intellij.openapi.ui.SimpleToolWindowPanel;
import com.intellij.ui.components.JBScrollPane;

import javax.swing.*;

public class DemoToolWindow {
    private JPanel contentToolWindow = null;

    public JComponent getContent() {
        return contentToolWindow;
    }

    public DemoToolWindow() {
        contentToolWindow = new SimpleToolWindowPanel(true, false);
        JTextArea textArea = new JTextArea();
        JBScrollPane scrollPane = new JBScrollPane(textArea);
        contentToolWindow.setLayout(new BoxLayout(contentToolWindow, BoxLayout.Y_AXIS));
        contentToolWindow.add(scrollPane);
    }
}

Sin entrar mucho en detalle, primero creamos un SimpleToolWindowPanel(boolean vertical, boolean borderless) especificando que sea un componente vertical y con bordes. Posteriormente creamos un área de texto, la cual la añadiremos a un componente de scroll. Finalmente, dicho componente scroll con el área de texto será añadido al layout del panel.

Si os fijáis, todo esto son componentes Swing que han sido extendidos para el SDK de IntelliJ, colocando el prefijo «J».

6.1.3. Explicación de los componentes que ofrece el SDK de IntelliJ y cómo usarlos

Usar los componentes Swing extendidos por el SDK de IntelliJ nos facilita un poco el camino y hace que el «look and feel» de nuestro componente se integre con el del IDE. Como prueba, este es el resultado de la implementación de nuestra extensión:

Extensión integrada
Extensión integrada

Como podemos observar, el componente queda ubicado en la parte inferior del IDE, y el diseño del mismo está alineado con el del IDE. Además, podemos observar cómo incorpora los botones de minimizado y la rueda dentada de opciones de visualización, usando las herramientas que proporciona el propio IDE.

6.2. Implementación de una acción

Una vez implementada nuestra extensión procedemos a la creación de la acción. Dicha acción constará de una nueva entrada en el menú del Editor (click derecho) la cual sólo será visible cuando haya texto seleccionado. Una vez seleccionemos nuestra acción, dicho código o texto será llevado a la extensión de nuestro plugin.

6.2.1. Configuración del plugin.xml

Para añadir una acción, debemos de modificar nuestro plugin.xml con el siguiente snippet de action:

<actions>
    <action id="AddSelectedTextAction"
            class="com.example.demo.AddSelectedTextAction"
            text="Add to DemoTool"
            description="Adds selected text into DemoTool plugin"
            icon="AllIcons.FileTypes.Text" >

        <add-to-group group-id="EditorPopupMenu" 
			 anchor="before" 
			 relative-to-action="$SearchWeb"/>
    </action>
</actions>

Con esta configuración estamos indicando que vamos a tener una acción con la siguiente información:

  • id – la referencia a la acción.
  • class – la clase que va a implementar la acción.
  • text – el texto a mostrar en el menú.
  • description – descripción de la propia acción.
  • icon – icono a ser mostrado junto al «text» en el menú. Vamos a usar la misma imagen que hemos usado en la extensión.

A su vez, le indicamos a la acción en qué menú va a ser ubicada usando el tag «add-to-group»:

  • group-id – el menú en el que se va a ubicar (en nuestro caso en el menú al hacer click derecho en el Editor).
  • relative-to-action – referencia a otra acción dentro del menú para ser ubicada junto a ella.
  • anchor – con esta opción indicamos si va a ir antes o después de la posición relativa que hemos elegido en el punto anterior. En nuestro caso, nuestra acción estará disponible antes de la acción de «$SearchWeb» (acción Search with Google)

6.2.2. Creación de las clases e implementación del código

Una vez añadida la configuración de la acción en el plugin.xml, procedemos a crear la clase que extienda de la acción:

package com.example.demo;

import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.editor.CaretModel;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.wm.ToolWindow;
import com.intellij.openapi.wm.ToolWindowManager;
import com.intellij.ui.components.JBScrollPane;
import org.jetbrains.annotations.NotNull;

import javax.swing.*;

public class AddSelectedTextAction extends AnAction {
    @Override
    public void actionPerformed(@NotNull AnActionEvent event) {
        // retrieve selected text from Editor
        Editor ediTorRequiredData = event.getRequiredData(CommonDataKeys.EDITOR);
        CaretModel caretModel = ediTorRequiredData.getCaretModel();
        String selectedText = caretModel.getCurrentCaret().getSelectedText();

        // retrieve JTextArea component to set selected text
        ToolWindow toolWindow = ToolWindowManager.getInstance(event.getProject()).getToolWindow("DemoTool");
        JViewport viewPort = ((JBScrollPane) toolWindow.getContentManager().getContent(0).getComponent()
                .getComponent(0)).getViewport();
        JTextArea textArea = (JTextArea) viewPort.getView();
        textArea.setText(selectedText);

        // show toolWindow extension when text is added
        toolWindow.show();

    }

    @Override
    public void update(@NotNull AnActionEvent event) {
        // retrieve model to check if there is a selected text
        CaretModel caretModel = event.getRequiredData(CommonDataKeys.EDITOR).getCaretModel();
        String selectedText = caretModel.getCurrentCaret().getSelectedText();
        event.getPresentation().setVisible(selectedText != null && !selectedText.isEmpty());
    }
}

Nuestra clase extiende de la clase abstracta AnAction. IntelliJ hace llamadas a los métodos de las acciones cuando un usuario interactúa con un menú o un toolbar.

En nuestro caso, sobre escribimos dos métodos:

  • actionPerformed() – este método es invocado cuando seleccionamos la acción desde el menú. En este caso lo que hace el método es recoger el texto seleccionado en el Editor, y posteriormente es añadido en el componente JTextArea.
  • update() – este método es invocado cada vez que la plataforma dispara el evento update. En este caso, se comprueba si existe código seleccionado en el Editor. Si lo hay, el evento se muestra en el menú dándonos la opción de seleccionarlo y disparar el evento actionPermormed().

Como muestra de ejemplo tenemos primero el menú con un código seleccionado:

Acción habilitada al seleccionar texto
Acción habilitada al seleccionar texto

Y, si clicamos en la opción «Add to DemoTool» podemos ver cómo el texto es copiado a nuestra extensión:

Texto añadido
Texto añadido

Si, por el contrario, no hubiera ningún texto seleccionado, dicha acción no se muestra en el menú:

Acción no disponible
Acción no disponible

7. Ejecución del plugin y comandos Gradle.

Para ejecutar nuestro plugin o depurarlo, por defecto IntelliJ nos ofrece la opción de lanzar la ejecución de un IDE de prueba. Para ello podemos ejecutarlo en el propio menú de IntelliJ:

Ejecución
Ejecución

Pero, en su defecto, podemos usar las tareas que nos ofrece Gradle:

Tareas de Gradle
Tareas de Gradle

Como podemos ver se nos muestran varias tareas, pero las que más nos interesan son las que se encuentran en el apartado «intellij»:

  • buildPlugin – esta tarea ensambla el plugin y prepara un archivo ZIP para ser desplegado.
  • runIde – ejecuta una instancia del IDE con el plugin instalado.
  • verifyPlugin – comprueba el contenido del archivo «plugin.xml» y sus descriptores, además de la estructura del proyecto.
  • signPlugin – firma el archivo ZIP generado con la clave del Marketplace.
  • publishPlugin – publica el plugin el el repositorio del Marketplace.

8. Instalación del plugin.


Hay dos maneras de instalar el plugin que acabamos de crear:

La primera sería una instalación manual. Para ello, una vez creado nuestro plugin, procedemos a realizar un buildPlugin desde la tarea de Gradle que hemos visto en el punto anterior. Posteriormente, desde el Marketplace de IntelliJ, procedemos a instalarlo seleccionando la opción mostrada a continuación:

Instalación manual
Instalación manual

Tras pulsar en instalar plugin desde disco seleccionamos la ubicación de nuestro jar previamente generado:

Selección de .jar
Selección de .jar

Una vez hecho esto, podemos ver nuestro plugin instalado:

Plugin instalado
Plugin instalado

Si nos fijamos, tanto el nombre como descripción del plugin aparecen con los valores por defecto que dejamos en el plugin.xml, al igual que el icono, que nos aparece el que asigna el wizard de creación por defecto.

Otra opción de instalación es la publicación del plugin en el Marketplace. Para ello habría que rellenar toda la información necesaria, firmar el plugin con la key de IntelliJ y publicarlo. Una vez publicado aparecería en el buscador del Marketplace.

9. Conclusiones


Como hemos visto, el desarrollo de un plugin para IntelliJ es muy sencillo. Lejos han quedado los tiempos en los que desarrollar cualquier extensión para IDE’s más antiguos era una empresa muy costosa, sólo reservada para los propios creadores del IDE o para organizaciones con los suficientes recursos.

De una manera muy rápida podemos crear cualquier tipo de plugin que nos resuelva una necesidad o nos automatice un proceso diario. Y además, dicha solución puede ser volcada en nuestra organización o, incluso, en la comunidad.

Desde aquí os animamos a que os lancéis en la creación de vuestros propios plugins/temas y que los compartáis con todos nosotros 🙂

En este repositorio de GitHub puedes encontrar todo el código generado durante la creación del tutorial.

 

 

Hey you!… este tutorial ha sido redactado escuchando Pulse, de Pink Floyd, y Return to Ommadawn, de Mike Oldfield.

DEJA UNA RESPUESTA

Por favor ingrese su comentario!

He leído y acepto la política de privacidad

Por favor ingrese su nombre aquí

Información básica acerca de la protección de datos

  • Responsable:
  • Finalidad:
  • Legitimación:
  • Destinatarios:
  • Derechos:
  • Más información: Puedes ampliar información acerca de la protección de datos en el siguiente enlace:política de privacidad