Меню Рубрики

Установка плагина build it

Разработка плагина IntelliJ IDEA. Часть 1

За последнее время у меня накопилось достаточно материалов по разработке плагинов для IntelliJ IDEA, чем и собираюсь поделиться с хабрасообществом.

Среда разработки и инфраструктура

Прежде чем начать программировать плагин стоит рассмотреть устройство среды разработки, поддерживаемые функции и их реализацию, и, разумеется, настройку IDE необходимую для разработки плагинов.

Для разработки плагинов подойдет любая современная версия Intellij IDEA – она уже включает в себя полный набор необходимого инструментария.
Для настройки среды разработки следует выполнить несколько шагов:

  • скачать исходные коды соответствующей версии Intellij IDEA Community Edition;
  • создать SDK типа «Intellij Platform Plugin SDK» (на рисунке ниже) и указать путь до установленной Community Edition (можно использовать Ultimate Edition, но отладка функций внутреннего API работает только в CE);
  • в настройках SDK, на странице Sourcepath необходимо указать путь до загруженных на п.1 исходных кодов;
  • создать новый модуль с типом «Platform Plugin» и присвоить ему ранее созданный SDK.

После чего можно приступать к разработке плагина как обычного Java-проекта, но с дополнительной возможностью видеть исходный код внутреннего API и трассировать его исполнение в отладчике.

Номера сборок

Это ограничения на диапазон поддерживаемых версий, используемые интегрированной средой для определения возможности корректной работы конкретного плагина. Начальный и конечный номера билдов указываются в файле plugin.xml, как и прочая метаинформация.
Начиная с IntelliJ IDEA 9 используется составная нумерация билда: например, IU-90.94. Этот номер состоит из следующих частей:

  • идентификатор продукта (IC для IDEA Community, IU для IDEA Ultimate, RM для RubyMine и PY для PyCharm);
  • номер ветви;
  • номер билда в этой ветке.

Каждый раз, когда создается очередная релизная ветвь одного из продуктов, основанных на платформе IntelliJ, номер ветки увеличивается на 1, а номер в транке на 2, таким образом, нестабильные билды имеют четный номер, а стабильные – нечетный.

Составные номера билдов могут применяться в тегах since-build и until-build в файле plugin.xml. Обычно идентификатор продукта опускают, используя лишь номер ветки и билда:

Совместимость плагинов с продуктами на платформе IntelliJ

Все продукты, базирующиеся на IntelliJ Platform (IntelliJ IDEA, RubyMine, WebStorm, PhpStorm, PyCharm и AppCode) разделяют общий нижележащий API платформы. Таким образом, плагины, не использующие какую-либо специфичную Java функциональность могут быть помечены как совместимые с другими продуктами, а не только с самой IDEA. Сделать это можно определив зависимости от модулей в файле plugin.xml.
Зависимости помещаются внутри тега
Если плагин не включает теги с зависимостями в plugin.xml, то он считается устаревшим и способен запуститься только в IDEA. Если plugin.xml содержит по крайней мере один такой тег, то он загрузится если в продукте содержатся все модули на которые он ссылается.
На данный момент следующие модули доступны во всех продуктах семейства IntelliJ:

  • com.intellij.modules.platform;
  • com.intellij.modules.lang;
  • com.intellij.modules.vcs;
  • com.intellij.modules.xml;
  • com.intellij.modules.xdebugger.

А эти модули доступны только в соответствующих продуктах:

  • com.intellij.modules.java – IntelliJ IDEA;
  • com.intellij.modules.ruby – RubyMine;
  • com.intellij.modules.python – PyCharm;
  • com.intellij.modules.objc – AppCode.

PhpStorm не обладает специфичным модулем, но включает в себя PHP плагин, который тоже возможно использовать как зависимость: com.jetbrains.php.
Также возможно использовать необязательные зависимости. Если плагин работает со всеми продуктами, но предоставляет некоторую специфичную Java функциональность, то можно использовать следующий тег:

Перед определением плагина совместимым с остальными продуктами, стоит убедиться, что не используются никакие функции специфичные для API IntelliJ IDEA. Для того чтобы сделать это, необходимо создать SDK указывающей на установленный RubyMine или PyCharm, скомпилировать плагин с этим SDK и проверить его работоспособность.

Структура плагина IntelliJ IDEA

Плагины – это единственный поддерживаемый путь расширения функциональности IDEA. Плагин использует предоставляемый программный интерфейс среды или других плагинов для реализации собственной функциональных возможностей. Обратим внимание на структуру и жизненный цикл плагина.

Содержимое плагинов

Существуют три способа организации содержимого плагина.
Первый – плагин содержит один jar-файл, размещенный в папке plugins. В архиве должен находиться конфигурационный файл (META-INF/plugin.xml) и классы, которые реализуют функциональность плагина. Конфигурационный файл определяет имя плагина, описание, данные о разработчике, поддерживаемая версия IDE, компоненты, действия, группы действий.

Второй способ – файлы плагина размещены в папке:

Classes и lib автоматически добавляются в classpath.
Третий способ – файлы плагина помещаются в jar-файл, находящийся в папке lib:

Загрузчики классов

Чтобы загрузить классы каждого плагина, IDEA использует раздельные загрузчики классов. Это позволяет использовать различные версии библиотеки, даже если она используются самой IDEA или другим плагином.
По-умолчанию, основной загрузчик классов загружает только те классы, которые не были найдены загрузчиком плагина. Тем не менее, в plugin.xml, в секции depends можно определить зависимости от других плагинов. В таком случае, загрузчики классов этих плагинов будут использованы для разрешения не найденных классов в текущем плагине. Это позволяет ссылаться на классы из других плагинов.

Компоненты плагинов

Компоненты – это фундаментальный концепт интеграции плагинов. Существуют три вида компонентов:

  1. уровня приложения;
  2. уровня проекта;
  3. уровня модуля.

Компоненты уровня приложения создаются и инициализируются во время старта IntelliJ IDEA.
Они могут быть получены от экземпляра класса Application с помощью метода getComponent(Class).

Компоненты уровня проекта создаются для каждого экземпляра класса Project (они могут быть созданы даже для неоткрытого проекта). Их можно получить от экземпляра Project вызовом метода getComponent(Class).

Компоненты уровня модуля создаются для каждого модуля в каждом проекте, загруженном в IDEA. Они могут быть получены аналогичным методом от экземпляра Module.

Читайте также:  Установка катализатора на астре

Каждый компонент должен реализовать интерфейс, определенный в конфигурационном файле. Интерфейс класса будет использован для получения компонента из других компонентов, реализация класса будет использована в процессе инициализации компонента. Важно отметить, что два компонента на одном уровне (модуля, проекта, приложения) не могут иметь одинаковый интерфейс.

Каждый компонент обязан иметь уникальное имя, которое будет использовано при экспортировании и прочих внутренних нуждах. Имя компонента возвращает метод getComponentName(). Рекомендуется применять следующее имя компонента: .

Дополнительно, класс, реализующий интерфейс компонента уровня приложения также может реализовывать интерфейс ApplicationComponent. Компонент приложения, не имеющий ни одной зависимости должен предоставлять конструктор без параметров, который будет вызван при создании. Если компонент зависит от других, он может принимать их как параметры конструктора, IDEA гарантирует, что эти компоненты будут корректно инициализированы в правильном порядке.

Классы, имеющие функциональность компонента уровня проекта реализуют интерфейс ProjectComponent. В конструкторе класса компонента должен быть параметр типа Project, если он использует экземпляр проекта. Также он может принимать другие компоненты уровня приложения или проекта как параметры, при наличии зависимости от них.

Компоненты уровня проекта должны быть зарегистрированы в секции

конфигурационного файла. Как и в случае компонентов приложения можно воспользоваться помощью IDE, выбрав подменю «New | Project Component».

Компоненты уровня модуля реализуют интерфейс ModuleComponent. Зависимости компонента могут быть переданы как параметры конструктора. Компоненты должны быть зарегистрированы в вручную или посредством выполнения пункта контекстного меню «New | Module Component».

Сохранение состояния компонентов
Жизненный цикл компонентов

Компоненты загружаются в следующем порядке:

  • создание – выполнение конструктора;
  • инициализация – вызов метода initComponent (если реализован интерфейс ApplicationComponent);
  • конфигурация – вызов readExternal (если реализован JDOMExternalizable) или loadState (если реализован PersistentStateComponent и компонент в состоянии не по-умолчанию);
  • для компонентов уровня модуля – вызов moduleAdded (если реализован ModuleComponent);
  • для компонентов уровня проекта – projectOpened (если реализован интерфейс ProjectComponent).

Компоненты выгружаются в следующем порядке:

  • сохранение конфигурации – вызов writeExternal (если реализован интерфейс JDOMExternalizable) или getState (если реализован PersistentStateComponent);
  • освобождение ресурсов – вызов метода disposeComponent.

В конструкторе компонента запрещено использовать метод getComponent() для получения каких-либо зависимостей. Если данному компоненту нужно получить другие компоненты при инициализации, они должны быть переданы в параметрах конструктора, либо перенести инициализацию в метод initComponent().

Расширения плагинов и точки расширения

Intellij IDEA предоставляет концепт расширений и точек расширения, которые позволяют взаимодействовать с другими плагинами и ядром IDEA.
Если требуется, чтобы плагин позволял расширять его функциональность, то необходимо определить одну или несколько точек расширения. Каждая такая точка определяет класс или интерфейс, который определяет протокол доступа к ней. Это же касается и расширений плагина.

Определить расширения и точки расширения можно в конфигурационном файле в секциях
Атрибут «interface» устанавливает интерфейс, который должен быть реализован для расширения функциональности. Атрибут «beanClass» определяет класс, содержащий одно или несколько свойств помеченных аннотацией @Attribute . Плагин, предоставляющий точку расширения прочитает эти свойства из файла plugin.xml.
Рассмотрим пример с MyBeanClass1:

Чтобы объявить расширение с доступом к точке расширения MyExtPoint, конфигурационный файл должен содержать тег с атрибутами «key» и «implementationClass» с соответствующими значениями.

Для регистрации расширения требуется выполнить следующие шаги:

  1. в элементе установить значение атрибута «xmlns» (устарел) или «defaultExtensionNs» одним из следующих:
    • «com.intellij», если плагин расширяет функциональность ядра IDEA;
    • , если плагин расширяет функциональность другого плагина.

    добавить новый дочерний элемент в секцию , название тега должно совпадать с идентификатором точки расширения;
    определить тип точки расширения, выбрав из следующих:

    • если точка расширения объявлена с атрибутом «interface», то в дочернем элементе необходимо указать атрибут «implementation», значение которого – класс, реализующий этот интерфейс;
    • если точка расширения объявлена с атрибутом «beanClass», то дочерний элемент должен содержать все атрибуты, которые были помечены в этом классе аннотацией @Attribute .

Действия (Actions)

Также Intellij IDEA предоставляет концепт действий (actions).
Действие – это класс, наследуемый от AnAction, чей метод actionPerformed() вызывается, когда выбран элемент меню или кнопка тулбара.

Действия объединяются в группы, которые также могут содержать вложенные группы. Группы действий могут быть отображены как меню или тулбары. Подгруппы отображаются как подменю.
Позже действия будут рассмотрены более подробно.

Сервисы

Сервис – это компонент, загружаемый по требованию, когда плагин вызывает метод getService() класса ServiceManager. Intellij IDEA гарантирует, что будет создан только один экземпляр сервиса, независимо от того сколько раз был вызван метод.

Сервисы должны иметь интерфейс, определенный в plugin.xml. Класс с реализацией будет использован при создании сервиса.

Сервисы подразделяются по уровням подобно компонентам, т.е. на сервисы уровня приложения, проекта и модуля, которым соответствуют точки расширения applicationService, projectService и moduleService соответственно.

Чтобы объявить сервис необходимо:

  • добавить соответствующий дочерний элемент ( , , ) в секцию ;
    для добавленного элемента установить следующие атрибуты:
    • «serviceInterface» – интерфейс сервиса;
    • «serviceImplementaion» – реализация сервиса.

    Классы интерфейса и реализации могут совпадать.
    Пример из файла plugin.xml:

    В следующей части: конфигурационный файл, действия, проекты и др.

    источник

    Installing plugins

    CKEditor 5 plugins are distributed through npm packages and are implemented in a modular way, which means that a single plugin may consist of multiple JavaScript files.

    In this guide you can learn how to add plugins to your editor in the two most common scenarios:

    If you are looking for an easy way to create a custom build of CKEditor 5 without installing anything, check the online builder, which allows you to create easily a build with a custom set of plugins through a simple and intuitive UI.

    # Requirements

    In order to start developing CKEditor 5 you will require:

    • Node.js 6.9.0+
    • npm 4+ (note: some npm 5+ versions were known to cause problems, especially with deduplicating packages; upgrade npm when in doubt)

    # Adding a plugin to a build

    Adding plugins to existing builds is done through their customization. Editor builds are maintained in their respective GitHub repositories. Therefore, assuming that you want to customize the classic editor build you need to:

    1. Clone the build repository.
    2. Install the plugin package.
    3. Add it to the build configuration.
    4. Bundle the build.

    Now, install the plugin package:

    Edit the src/ckeditor.js file to add your plugin to the list of plugins which will be included in the build and to add your feature’s button to the toolbar:

    If everything worked, the editor build (which is available in the build/ directory) should be updated.

    You can open the sample/index.html file in your browser to see whether the plugin was installed correctly.

    This was a quick version of how a build can be customized. Read more about customizing existing editor builds in a separate guide.

    # Adding a plugin to an editor

    If you build the editor from source, then the process of installing a new plugin boils down to these three steps:

    1. Installing the plugin package.
    2. Adding it to your editor’s configuration.
    3. Building your project.

    For example, if you wish to install the text alignment feature:

    Edit the code that initializes the editor:

    After rebuilding your project, the new feature will be available in the editor.

    One of the possible mistakes is trying to add a plugin in this way to an existing (bundled) editor build. Installing an existing build and then trying to add a plugin to it may not work if that plugin needs to import any of the source editor modules.

    The reason why this method will not work is that dependencies of the added plugin may duplicate the code already bundled in the used editor build. In the best scenario, this is going to raise the overall code size. In the worst scenario, an application built this way may be unstable.

    # Difference between both methods

    What is the difference between adding a plugin to an editor build and adding a plugin by passing the config.plugins option to the static create() method?

    The first method builds the plugin into the editor class. This means that you can then initialize the editor without passing config.plugins at all and the editor will automatically enable all built-in plugins:

    All this works because a typical src/ckeditor.js module that you can find in every editor build repository (see for example @ckeditor/ckeditor5-build-classic ) looks like this:

    This code imports the source of the classic editor and extends it with a static builtinPlugins and defaultConfig properties where it defines a set of plugins and configuration to be used by this editor class.

    In this approach, all editor instances created by using this editor build will by default load all these built-in plugins and configuration.

    You can still use the config.removePlugins and config.plugins options to override the default configuration.

    When building the editor from source and not using a build as a base, you can also use the static builtinPlugins and defaultConfig properties of editor classes. However, in this situation it is usually more convenient to simply pass all the plugins directly to the static create() method:

    So, in short, both methods use very similar mechanisms. However, adding a plugin through the static builtinPlugins property (which happens in editor builds) lets you automatically enable it in all editor instances created using this editor class, while passing a plugin to create() will naturally affect only one instance.

    источник

    Лучшие плагины IntelliJ IDEA

    Key promoter X

    Использование сочетаний клавиш вместо мыши может значительно повысить производительность. С таким количеством функций, которые предлагает IDEA, это может быть пугающим и трудным для изучения всех быстрых клавиш. К счастью, есть плагин под названием Key Promoter X, который может вам помочь.

    Идея проста: всякий раз, когда вы используете мышь для вызова команды в вашей IDE, появляется всплывающее окно, которое сообщает вам, каково сочетание клавиш для этого действия.

    Он даже предлагает вам назначить сочетание клавиш для только что выполненного действия, если такого еще нет. Через некоторое время это становится настолько раздражающим, что вы скорее убедитесь, что вы помните свои сочетания клавиш.

    К сожалению, безопасность приложений часто игнорируется. В настоящее время большая часть кода приложения поступает из сторонних библиотек и сред. Вы должны убедиться, что вы используете новые версии без уязвимостей безопасности. Есть инструменты, которые могут помочь вам в этом. Одним из них является Snyk.

    Snyk предлагает много возможностей. Одним из них является плагин IDE, который может сканировать ваши зависимости и определять, какие уязвимости безопасности они содержат.

    Presentation assistant

    Это простой плагин, который показывает всплывающее уведомление каждый раз, когда вы выполняете действие в IDEA. Он показывает, какое действие было выполнено и какое сочетание клавиш связано с ним.

    Это может быть очень полезно при проведении презентаций, во время скринкастов, парного программирования и так далее. Особенно при использовании сочетаний клавиш может быть трудно следить за тем, что происходит без этого плагина.

    Edu Tools

    Это отличный плагин для уроков кодирования, семинаров и так далее. Он позволяет создавать курсы с набором задач, которые можно выполнять непосредственно в вашей среде IDE. Вы можете создавать свои собственные курсы или импортировать публичные курсы.

    Он доступен как в виде отдельного плагина, так и в виде IntelliJ IDEA Edu Edition, который в основном является версией IDEA Community с уже установленным плагином.

    Extra icons

    Это в основном пакет иконок, в котором предоставлены новые иконки для специальных файлов, таких как конфигурация Travis, package.json, lint config и многие другие.

    Это может быть очень полезно, так как вы можете сразу же распознать эти специальные файлы, и, следовательно, навигация по вашему проекту будет намного проще. Например, package.json — это файл с расширением json, но гораздо полезнее иметь для него специальный значок, так как это важный файл для проектов npm.

    Grazie

    IntelliJ IDEA имеет базовую проверку орфографии, которая позволяет обнаруживать некоторые опечатки, но, в целом, она не очень полезна. Она, определенно, не является заменой специализированным службам проверки грамматики, таким как Grammarly.

    К счастью, есть плагин Grazie, который расширяет базовую проверку орфографии с помощью множества полезных функций. Он также обнаруживает более сложные проблемы, такие как неправильная грамматика. Он также работает полностью в автономном режиме.

    Плагин Grazie позволяет также включить проверку сообщений о коммите. Вы можете узнать больше в блоге Встречайте Grazie: полная проверка орфографии, грамматики и стиля для IntelliJ IDEA.

    Помощник Maven

    IDEA уже имеет мощные инструменты для анализа ваших зависимостей и потенциальных проблем с ними, таких как конфликты или циклические зависимости.

    Помощник Maven предлагает альтернативный пользовательский интерфейс, который иерархически отображает ваши зависимости. Он может быть проще для чтения и навигации. Кроме того, если вы используете версию IDEA community, это ваш единственный вариант.

    InnerBuilder

    Создание сложных объектов может быть трудным. Конечно, вы можете основывать разработку на простых POJO с целой кучей сеттеров, но вы не сможете гарантировать, что все созданные объекты имеют все обязательные поля и не используются в неполном состоянии. Чтобы решить эту задачу, вам нужны конструкторы. С более сложными объектами это может привести к целому ряду телескопических конструкторов со многими параметрами. В этих случаях использование шаблона Строитель (Builder) гораздо уместнее.

    Этот плагин может автоматически генерировать для вас Builder из POJO.

    Rainbow Brackets

    Если вы боретесь с множеством вложенных блоков и множеством скобок, этот плагин для вас. Это позволяет легко найти соответствующие скобки, так как каждая пара скобок имеет цветовую кодировку.

    С цветовой темой по умолчанию читать довольно сложно, поэтому Darcula гораздо лучше подходит для использования этого плагина.

    Indent Rainbow

    Этот плагин похож на скобки Rainbow, но он окрашивает не ваши скобки, а отступы. Это может быть полезно, если у вас много уровней отступов, по которым сложнее ориентироваться. Он может даже помечать красным цветом строки, которые не имеют правильные уровни отступов, так что сразу становятся очевидными несоответствия.

    Опять же, это гораздо менее заметно в светлой теме, поэтому Darcula может быть лучшим выбором.

    String Manipulation (Манипуляция строками)

    Это удобный плагин, который позволяет вам выполнять различные действия с вашими строками, такие как:

    • Эскейпинг / исключение для различных контекстов (Java, HTML, XML, SQL, . )
    • Переключение регистра (нижний, верхний, кебаб, паскаль, верблюд, . )
    • Сортировка
    • Поиск
    • Тримминг

    Git Toolbox (Инструментарий)

    Хотя поддержка git в IntelliJ уже довольно хороша, этот плагин все же предлагает некоторые полезные функции.

    Вы можете легко увидеть, на сколько коммитов ваша ветка впереди/позади. Вы можете настроить автоматическую выборку с настраиваемой частотой. Вы можете автоматически видеть информацию об ответственнных в вашей текущей строке.

    Request Mapper

    IDEA уже предлагает довольно мощную навигацию между файлами. При работе с конечными точками REST иногда вы можете предпочесть перейти к определенному маппингу (например, /persons) вместо класса (например, PersonController). Это в тех случаях, когда вы знаете URL, но не помните, какому классу или методу он соответствует. После нажатия на соответствующую комбинацию клавиш вы можете выполнить поиск маппинга URL адресов и перейти к ним напрямую.

    Плагин в настоящее время поддерживает Spring, JAX-RS и Micronaut.

    Multirun

    IDEA поддерживает запуск нескольких задач (конфигураций) одновременно, однако эта функция в настоящее время очень ограничена.

    Плагин Multirun поддерживает запуск нескольких конфигураций одновременно с гораздо более сложными опциями. Это может быть очень полезно при одновременном запуске Backend и Frontend, тестировании нескольких модулей и т.д.

    IDEA Mind Map

    Может быть очень полезно иметь редактор и средство просмотра интеллект карт (Mind Map), непосредственно интегрированные в вашу IDE. Не только для быстрого мозгового штурма, но и для подготовки документации. Плагин работает с MMD-файлами, которые основаны на тексте, поэтому очень просто держать свои интеллект карты под контролем версий и управлять их изменениями.

    Codota и TabNine

    Эти два плагина похожи. Они улучшают ваше автозаполнение на основе сканирования проектов с открытым исходным кодом и интеллектуального прогнозирования того, что вы, вероятно, хотите набрать, исходя из контекста.

    С Codota вы также можете искать соответствующие примеры некоторых классов или методов в публичных проектах, что может быть удобно.

    источник