💻 Roberto Manchado | Backend Developer  
Regresar al blog
•
5 minutos de lectura

Cómo crear un plugin para PhpStorm

Puntos a ver ...

Los plugins son una excelente manera de extender la funcionalidad de PhpStorm y adaptarlo a tus necesidades específicas. En este post, te guiaré a través del proceso de creación de un plugin para PhpStorm utilizando el SDK de Plugin Development (PluginDev) y Gradle.

Requisitos previos

Antes de comenzar, necesitarás tener instalado:

  • IntelliJ IDEA (Community o Ultimate)
  • JDK 11 o superior
  • Git
  • Conocimientos básicos de Java y Kotlin

Configuración del entorno de desarrollo

1. Instalar Plugin Development Kit

El primer paso es instalar el Plugin Development Kit (PluginDev) en IntelliJ IDEA:

  1. Abre IntelliJ IDEA
  2. Ve a File > Settings > Plugins (o Preferences > Plugins en macOS)
  3. Busca “Plugin DevKit” en el marketplace
  4. Haz clic en “Install” y reinicia el IDE cuando se te solicite

2. Crear un nuevo proyecto de plugin

Ahora crearemos la estructura básica del proyecto:

  1. Ve a File > New > Project
  2. Selecciona “IntelliJ Platform Plugin” en el panel izquierdo
  3. Configura el nombre del proyecto y la ubicación
  4. Selecciona Kotlin como lenguaje de programación (recomendado, aunque también puedes usar Java)
  5. Haz clic en “Create”

Estructura del proyecto

Una vez creado el proyecto, verás una estructura similar a esta:

mi-plugin/
├── .gradle/
├── .idea/
├── build/
├── src/
│   ├── main/
│   │   ├── kotlin/
│   │   └── resources/
│   │       └── META-INF/
│   │           └── plugin.xml
│   └── test/
├── build.gradle.kts
├── gradle.properties
└── settings.gradle.kts

El archivo plugin.xml es el más importante, ya que define la configuración y puntos de extensión de tu plugin.

Configuración de build.gradle.kts

El archivo build.gradle.kts contiene la configuración de Gradle para construir tu plugin. Asegúrate de que tenga el siguiente contenido básico:

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

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

repositories {
    mavenCentral()
}

// Configura la versión de IntelliJ IDEA para el desarrollo
intellij {
    version.set("2023.1.4")
    type.set("PS") // PS para PhpStorm
    plugins.set(listOf("com.jetbrains.php:231.9011.38"))
}

tasks {
    // Configura Java compatibility
    withType<JavaCompile> {
        sourceCompatibility = "17"
        targetCompatibility = "17"
    }
    
    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
        kotlinOptions.jvmTarget = "17"
    }

    patchPluginXml {
        sinceBuild.set("231")
        untilBuild.set("241.*")
    }
    
    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"))
    }
}

Implementación básica

Ahora vamos a implementar una acción básica para nuestro plugin. Crea una nueva clase Kotlin en src/main/kotlin/com/tudominio/miplugin/:

package com.tudominio.miplugin

import com.intellij.openapi.actionSystem.AnAction
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.ui.Messages

class MiAccionPlugin : AnAction() {
    override fun actionPerformed(e: AnActionEvent) {
        Messages.showInfoMessage("¡Hola desde mi plugin de PhpStorm!", "Mi Plugin")
    }
}

Registro de la acción en plugin.xml

Abre el archivo src/main/resources/META-INF/plugin.xml y modifícalo para registrar tu acción:

<idea-plugin>
    <id>com.tudominio.miplugin</id>
    <name>Mi Plugin PhpStorm</name>
    <vendor email="tu@email.com" url="https://www.tudominio.com">Tu Nombre</vendor>
    
    <description><![CDATA[
    Descripción de tu plugin: qué hace y cómo ayuda a los desarrolladores.
    ]]></description>
    
    <!-- Asegúrate de que sea compatible con PhpStorm -->
    <depends>com.intellij.modules.platform</depends>
    <depends>com.jetbrains.php</depends>
    
    <extensions defaultExtensionNs="com.intellij">
        <!-- Define extensiones aquí si las necesitas -->
    </extensions>
    
    <actions>
        <action id="com.tudominio.miplugin.MiAccionPlugin" 
                class="com.tudominio.miplugin.MiAccionPlugin" 
                text="Ejecutar Mi Plugin" 
                description="Ejecuta la acción de mi plugin">
            <add-to-group group-id="ToolsMenu" anchor="last"/>
        </action>
    </actions>
</idea-plugin>

Compilar y ejecutar el plugin

Para compilar y probar tu plugin, puedes usar los siguientes comandos de Gradle:

# Para compilar el plugin
./gradlew build

# Para ejecutar una instancia de PhpStorm con tu plugin instalado
./gradlew runIde

# Para crear el archivo de distribución (.zip o .jar)
./gradlew buildPlugin

El archivo del plugin se generará en la carpeta build/distributions/.

Depuración del plugin

Para depurar tu plugin:

  1. Ve a Run > Edit Configurations
  2. Selecciona la configuración “runIde”
  3. Configura los puntos de interrupción en tu código
  4. Ejecuta el plugin en modo de depuración (Run > Debug)

Publicación del plugin

Una vez que estés satisfecho con tu plugin, puedes publicarlo en el JetBrains Plugin Repository:

  1. Asegúrate de que todos los metadatos en plugin.xml sean correctos
  2. Genera el archivo de distribución con ./gradlew buildPlugin
  3. Sube el archivo a JetBrains Plugin Repository

Resumiendo…

Crear un plugin para PhpStorm es una excelente manera de extender su funcionalidad y mejorar tu flujo de trabajo de desarrollo. Aunque la curva de aprendizaje puede ser pronunciada al principio, el SDK de desarrollo de plugins de JetBrains ofrece una amplia gama de herramientas y APIs para ayudarte a implementar casi cualquier funcionalidad que necesites.

Tutorial…

Para profundizar más en el desarrollo de plugins para PhpStorm, te recomiendo consultar estos recursos:

Cómo crear buenos prompts
Componente Lock