Возьмем Neovim на Луну

Я использую Neovim в качестве основного редактора кода уже некоторое время, и пока что я не изменил своего мнения. Я написал несколько статей об этом редакторе, и одна из них была о создании простого конфигурационного файла, который работает как для Neovim, так и для Vim. Этот файл до сих пор отлично работает, но, как и во всем остальном компьютерном мире, всегда есть другой способ достичь тех же целей. Одним из таких способов является конфигурирование Neovim с помощью языка Lua.

Я получил несколько запросов на создание конфигурации Lua, но я откладывал это до тех пор, пока мне снова не понадобилось конфигурировать Neovim с нуля. Такая возможность появилась недавно, так как мне нужно было настроить Ryzentosh (хакинтош с процессором Ryzen) для работы, и там был чистый Neovim для настройки. Прежде чем перейти к самому руководству, я прокомментирую несколько моментов.

Язык Lua

Пример кода на языке Lua

Lua — это язык программирования, созданный бразильцами Роберто Иерусалимши, Вальдемаром Селесом и Луисом Энрике де Фигейредо в PUC/RJ. Это высокоуровневый, мультипарадигмальный, легкий язык с динамической типизацией и автоматической сборкой мусора.

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

Поскольку одной из целей языка всегда было быть языком-спутником, «Lua» (Луна по-португальски) — вполне подходящее название. Простота изучения и значительная скорость работы стали положительными моментами в его принятии.

Эта статья не сделает вас мастером языка, да это и не является целью. Но вы будете знать достаточно для конфигурирования Neovim.

О конфигурационном файле

Neovim

В init.vim, который я сделал в другой статье, можно было создать один файл, содержащий все необходимое для комфортной работы с Neovim. С init.lua, который будет создан здесь, это также возможно, и именно это я и предлагаю. В другой раз мы разделим его на несколько файлов, так как это, похоже, стандартный способ.

Если вы новичок в Neovim, не пытайтесь следовать этому руководству. Начните с конфигурационного файла VimScript, созданного в другой статье, а когда вы освоитесь с окружением, возвращайтесь!

Конфигурационный файл

Для начала работы создайте файл init.lua в каталоге .config/nvim, расположенном в вашей папке пользователя:

$ cd ~/.config/nvim/
$ touch init.lua

Установка опций

Цель состоит в том, чтобы перевести init.vim, который у меня уже есть, на язык Lua.

В VimScript каждая опция устанавливается с помощью ключевого слова set. В Lua вы используете vim.opt.[имя опции], что, скажем прямо, не очень читабельно, если повторять несколько раз. Поэтому я решил поместить vim.opt в локальную переменную set (ничего себе!). Это делает все более знакомым и читаемым.

Вот опции, которые я использую:

---------------------------------
-- Opções
---------------------------------
local set = vim.opt

set.background = "dark"
set.clipboard = "unnamedplus"
set.completeopt = "noinsert,menuone,noselect"
set.cursorline = true
set.expandtab = true
set.foldexpr = "nvim_treesitter#foldexpr()"
set.foldmethod = "manual"
set.hidden = true
set.inccommand = "split"
set.mouse = "a"
set.number = true
set.relativenumber = true
set.shiftwidth = 2
set.smarttab = true
set.splitbelow = true
set.splitright = true
set.swapfile = false
set.tabstop = 2
set.termguicolors = true
set.title = true
set.ttimeoutlen = 0
set.updatetime = 250
set.wildmenu = true
set.wrap = true

Если вы пользовались Neovim, вы, вероятно, уже знакомы с некоторыми из этих опций, но если нет, то вот объяснение каждой из них:

Чтобы увидеть их в действии, просто выйдите из Neovim и запустите его снова (вы ведь знаете, как это сделать, не так ли?), или войдите в командный режим shift + : и введите luafile %. Это прочитает файл init.lua и применит опции к текущему экземпляру.

Синтаксис

Чтобы добавить поддержку автоматического определения синтаксиса для открытых файлов:

vim.cmd([[
  filetype plugin indent on
  syntax on
]])

Обратите внимание на vim.cmd: он позволяет использовать VimScript в файле .lua. В данном случае это очень практичный способ писать меньше кода.

Плагины

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

Packer: менеджер расширений для Neovim, написанный на Lua

Чтобы установить плагины, сначала нужно установить менеджер. Для этого будет использоваться Packer, так как он сделан на Lua и, очевидно, поддерживает конфигурацию на этом языке.

Если вы используете macOS или Linux, просто выполните эту команду в терминале:

$ git clone --depth 1 https://github.com/wbthomason/packer.nvim
 ~/.local/share/nvim/site/pack/packer/start/packer.nvim

После перезапуска Neovim у вас появится ряд команд, которые значительно упростят установку, обновление и удаление плагинов.

Чтобы добавить их в наш конфигурационный файл, просто добавьте следующие строки:

---------------------------------
-- Plugins
---------------------------------
local packer = require("packer")

-- Include packer.nvim
vim.cmd([[packadd packer.nvim]])

packer.startup(function()
  -- Plugins are listed here
end)

Обратите внимание на require("packer"): это способ импорта файлов в Lua. Для тех, кто использовал NodeJS, это очень знакомо. После этого добавляется команда в VimScript, чтобы Neovim распознал существование пакета Packer.

Чтобы добавить плагины для установки, просто включите use("user-in-github/repository") в анонимную функцию в packer.startup(). Первым плагином, который будет добавлен, будет сам Packer:

packer.startup(function()
  -- Plugin manager
  use("wbthomason/packer.nvim")
end)

Таким образом мы сможем обновлять Packer, а также другие плагины.

Плагины, используемые в этой установке

Вот список плагинов:

packer.startup(function()
  -- Completion
  use("hrsh7th/cmp-buffer")
  use("hrsh7th/cmp-cmdline")
  use("hrsh7th/cmp-nvim-lsp")
  use("hrsh7th/cmp-path")
  use("hrsh7th/nvim-cmp")
  -- Motor de snippets
  use("L3MON4D3/LuaSnip")
  use("saadparwaiz1/cmp_luasnip")
  -- Formatting
  use("jose-elias-alvarez/null-ls.nvim")
  -- Language server
  use("neovim/nvim-lspconfig")
  use("williamboman/nvim-lsp-installer")
  -- Syntax parser
  use("nvim-treesitter/nvim-treesitter")
  -- Plugin manager
  use("wbthomason/packer.nvim")
  -- Utilities
  use("windwp/nvim-autopairs")
  use("norcalli/nvim-colorizer.lua")
  use("lewis6991/gitsigns.nvim")
  -- Dependencies
  use("nvim-lua/plenary.nvim")
  use("kyazdani42/nvim-web-devicons")
  use("MunifTanjim/nui.nvim")
  -- File browser
  use("nvim-telescope/telescope.nvim")
  -- Interface
  use("akinsho/bufferline.nvim")
  use({ "nvim-neo-tree/neo-tree.nvim", branch = "v2.x" })
  use("nvim-lualine/lualine.nvim")
  -- Color scheme
  use("elvessousa/sobrio")
end)

Краткое объяснение функции каждого из них:

Автозаполнение

• Neovim CMP: движок для автозаполнения.
• CMP Buffer: добавляет автозаполнение на основе текста, набранного в открытых файлах (буферах).
• CMP CmdLine: автозаполнение командной строки.
• CMP nvim-lsp: автозаполнение с использованием языкового сервера.
• CMP Path: автозаполнение путей каталогов.

Механизм сниппетов

• LuaSnip e Cmp LuaSnip: движок сниппетов, необходимый для Neovim CMP

Форматирование

• Null LS: предоставляет несколько инструментов, таких как диагностика и форматирование кода.

Языковой сервер

• Neovim LSP Config: поддержка языковых серверов для Neovim.
• Neovim LSP Installer: установка языковых серверов из всплывающего окна.

Синтаксический анализатор

• Treesitter: подсветка синтаксиса.

Утилиты

• Neovim Autopairs: автоматически закрывает круглые скобки, квадратные скобки и фигурные скобки.
• Neovim Colorizer: отображает цвета HEX, RGB или HSL в редакторе.
• Neovim GitSigns: отображает git-изменения сбоку.

Зависимости

• Plenary: Фреймворк плагинов Lua для Neovim. Требуется для работы некоторых расширений.
• Neovim Web Devicons: позволяет использовать шрифты иконок в плагинах. Деталь: необходимо, чтобы «Nerd Font» был установлен в системе и применялся в эмуляторе терминала.
• NUI: Библиотека пользовательского интерфейса, используемая некоторыми плагинами.

Управление файлами

• Telescope: нечеткий поиск файлов.

Интерфейс

• Bufferline: панель вкладок
• Neo Tree: дерево файлов/папок. Альтернатива NetRW.
• Lualine: строка состояния, аналогичная Airline.

Тема

• Sobrio: тема, созданная мной, которую я использую ежедневно. Теперь с поддержкой TreeSitter.

Установка расширений

Для установки, как и в прошлый раз с VimPlug, необходимо использовать команду install. Однако, в отличие от VimPlug, за удаление, добавление или обновление расширений отвечает одна команда Packer: :PackerSync.

При использовании этой команды появится боковое разделение, которое покажет изменения, внесенные Packer в вашу установку Neovim. Не забывайте всегда использовать эту команду при добавлении или удалении плагинов из вашего списка.

Запуск плагинов

В дополнение к установке файлов с помощью Packer, вам необходимо инициализировать плагины, чтобы они могли использоваться в Neovim. Некоторые из них работают без опций, другие требуют дополнительных настроек. Чтобы увидеть работу некоторых расширений, мы сначала добавим самые простые:

---------------------------------
-- Misc plugins
---------------------------------
-- Autopairs
require("nvim-autopairs").setup({
    disable_filetype = { "TelescopePrompt" },
})

-- Colorizer
require("colorizer").setup()

-- Git signs
require("gitsigns").setup()

-- Bufferline
require("bufferline").setup()

-- Lualine
require("lualine").setup()

Это закономерность. Плагины обычно инициализируются с помощью require("plugin-name").setup().

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

Нео дерево

Neo Tree: Дерево каталогов

Neo Tree — это замена NetRW. По умолчанию оно и так прекрасно работает, но я рекомендую добавить приведенные ниже опции:

-- Neo tree
require("neo-tree").setup({
  close_if_last_window = false,
  enable_diagnostics = true,
  enable_git_status = true,
  popup_border_style = "rounded",
  sort_case_insensitive = false,
  filesystem = {
    filtered_items = {
      hide_dotfiles = false,
      hide_gitignored = false,
    },
  },
  window = { width = 30 },
})

Пояснения к опциям:

Цветовая схема

Sobrio: Тема, которую я создал и использую

В зависимости от темы, которую вы используете, конфигурация будет отличаться. Если выбранная вами тема имеет конфигурацию, доступную в Lua, процесс очень похож на плагины. В случае с моей темой Sobrio я просто добавил ее в vim.cmd, о котором я упоминал в начале статьи:

---------------------------------
-- Color scheme and syntax
---------------------------------
vim.cmd([[
  filetype plugin indent on
  syntax on
  colorscheme sobrio
]])

Вариации

Sobrio Ghost: вариант темы Sobrio, с прозрачным фоном

У этой созданной мной темы есть и другие варианты, например, светлая версия (Sobrio Light), вариант с альтернативными цветами (Sobrio Verde) и вариант с прозрачным фоном (Sobrio Ghost).

Конфигурация синтаксического анализатора

TreeSitter — это расширение, отвечающее за подсветку синтаксиса, представленную на экране. Результат обычно намного лучше, чем парсер по умолчанию в Neovim.

Ниже приведен пример конфигурации, совместимой с моим рабочим процессом:

---------------------------------
-- Syntax highlighting
---------------------------------
require("nvim-treesitter.configs").setup({
  ensure_installed = {
    "bash",
    "c",
    "cpp",
    "css",
    "elixir",
    "fish",
    "graphql",
    "html",
    "javascript",
    "json",
    "lua",
    "markdown",
    "markdown_inline",
    "php",
    "python",
    "regex",
    "ruby",
    "rust",
    "scss",
    "sql",
    "toml",
    "tsx",
    "typescript",
    "vim",
    "yaml",
  },
  highlight = { enable = true },
  indent = { enable = true },
  autotag = {
  enable = true,
  filetypes = {
    "html",
    "javascript",
    "javascriptreact",
    "svelte",
    "typescript",
    "typescriptreact",
    "vue",
    "xml",
  },
  },
})

Краткое объяснение опций:

Завершение кода

nvim-cmp

Neovim CMP или nvim-cmp — это расширение, которое обеспечивает завершение кода в Neovim. Для его работы необходимо наличие нескольких других связанных расширений.

---------------------------------
-- Completion
---------------------------------
local cmp = require("cmp")

cmp.setup({
  snippet = {
    expand = function(args)
      require("luasnip").lsp_expand(args.body)
    end,
  },
  mapping = cmp.mapping.preset.insert({
    ["<C-b>"] = cmp.mapping.scroll_docs(-4),
    ["<C-f>"] = cmp.mapping.scroll_docs(4),
    ["<C-Space>"] = cmp.mapping.complete(),
    ["<C-e>"] = cmp.mapping.abort(),
    ["<CR>"] = cmp.mapping.confirm({ select = true }),
  }),
  sources = cmp.config.sources({
    { name = "nvim_lsp" },
    { name = "luasnip" },
    { name = "buffer" },
    { name = "path" },
  }),
})

-- File types specifics
cmp.setup.filetype("gitcommit", {
  sources = cmp.config.sources({
    { name = "cmp_git" },
  }, {
    { name = "buffer" },
  }),
})

-- Command line completion
cmp.setup.cmdline("/", {
  mapping = cmp.mapping.preset.cmdline(),
  sources = { { name = "buffer" } },
})

cmp.setup.cmdline(":", {
  mapping = cmp.mapping.preset.cmdline(),
  sources = cmp.config.sources({
    { name = "path" },
  }, {
    { name = "cmdline" },
  }),
})

Большую часть этого кода я вставил в соответствии с предложениями, доступными в репозитории автора. Единственное, что я сделал, это адаптировал его для использования с механизмом предложений LuaSnip.

В опции snippet вы настраиваете, какой движок предложений будет использоваться. В mapping добавлены сочетания клавиш для команд CMP. Опция sources позволяет сортировать источники предложений по приоритету. Приведенный выше код устанавливает следующие приоритеты:

1. Предложения языкового сервера
2. Предварительно созданные коды LuaSnip
3. Слова, записанные в текущем файле
4. Пути каталогов на вашем компьютере

Блок cmp.setup.filetypes позволяет настроить поведение Neovim CMP для заданного типа файлов. В данном случае, правила использования cmp_git в операциях, связанных с Git.

cmp.setup.cmdline настраивает параметры командного режима Neovim. Наличие двух блоков объясняется тем, что команды могут начинаться с символов / или :, и в каждом случае приоритеты предложений меняются.

Форматирование кода

NullLS — это расширение, которое предоставляет различные инструменты на основе языкового сервера. Одним из таких инструментов является форматирование кода.

По умолчанию ничего не делается. Вам необходимо добавить некоторые настройки, чтобы NullLS заработал. Ниже приведены примеры настроек для тех, кто использует Python, Rust, PHP, JavaScript/TypeScript, HTML, CSS/SCSS и Lua.

---------------------------------
-- Formatting
---------------------------------
local diagnostics = require("null-ls").builtins.diagnostics
local formatting = require("null-ls").builtins.formatting
local augroup = vim.api.nvim_create_augroup("LspFormatting", {})

require("null-ls").setup({
  sources = {
    formatting.black,
    formatting.rustfmt,
    formatting.phpcsfixer,
    formatting.prettier,
    formatting.stylua,
  },
  on_attach = function(client, bufnr)
    if client.name == "tsserver" or client.name == "rust_analyzer" or client.name == "pyright" then
      client.resolved_capabilities.document_formatting = false
    end

    if client.supports_method("textDocument/formatting") then
      vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
      vim.api.nvim_create_autocmd("BufWritePre", {
        group = augroup,
        callback = function()
          vim.lsp.buf.formatting_sync()
        end,
    })
    end
  end,
})

---------------------------------
-- Auto commands
---------------------------------
vim.cmd([[ autocmd BufWritePre <buffer> lua vim.lsp.buf.formatting_sync() ]])

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

Функция в on_attach имеет два назначения:

1. Отключает форматирование на некоторых серверах, чтобы NullLS не спрашивал, какой шрифт использовать каждый раз, когда он применяет форматирование, или чтобы не было странного поведения.
2. Создать autocmd для применения форматирования при сохранении, если текущий файл поддерживается.

Установка форматеров

Каждый форматер имеет свой собственный способ установки, но в целом они доступны тремя способами:

1. Менеджер пакетов для языка программирования: Cargo для Rust, PIP для Python, NPM или Yarn для JavaScript/TypeScript.
2. Системный менеджер пакетов: Homebrew для macOS; Pacman, APT, DNF и т.д. для дистрибутивов Linux.
3. Компиляция непосредственно из исходного кода. Если вы не являетесь пользователем Gentoo Linux или хотите внести свой вклад в разработку языкового сервера, я не рекомендую этот вариант.

Примеры установки

В данной установке использовались следующие форматеры: Black (Python), Rustfmt (Rust), PHP CS Fixer (PHP), Prettier (JavaScript и производные, HTML, CSS и производные) и Stylua (Lua).

Чтобы установить Stylua, Prettier, PHP CS Fixer и Black, используйте соответствующие менеджеры пакетов:

$ cargo install stylua
$ pip install black
$ (sudo) npm i -g prettier
$ composer global require friendsofphp/php-cs-fixer

Чтобы установить Stylua с помощью Pacman в Arch Linux:

$ sudo pacman -S stylua

Используя Homebrew, вы можете установить PHP CS Fixer следующим образом:

$ brew install php-cs-fixer

Кстати, Homebrew предназначен не только для macOs. Он также доступен для Linux и Windows.

Языковые серверы

Neovim имеет встроенный детектор языков. Его можно настроить с нуля, но чтобы помочь в этом процессе, команда Neovim сделала расширение Neovim LSP Config. С его помощью просто запустите lspconfig, указав имя языкового сервера, который вы хотите активировать в Neovim. Вот пример ниже:

---------------------------------
-- Language servers
---------------------------------
local lspconfig = require("lspconfig")
local caps = vim.lsp.protocol.make_client_capabilities()
local no_format = function(client, bufnr)
  client.resolved_capabilities.document_formatting = false
end

-- Capabilities
caps.textDocument.completion.completionItem.snippetSupport = true

-- Python
lspconfig.pyright.setup({
  capabilities = caps,
  on_attach = no_format
})

-- PHP
lspconfig.phpactor.setup({ capabilities = caps })

-- JavaScript/Typescript
lspconfig.tsserver.setup({
  capabilities = caps,
  on_attach = no_format
})

-- Rust
lspconfig.rust_analyzer.setup({
  capabilities = snip_caps,
  on_attach = no_format
})

-- Emmet
lspconfig.emmet_ls.setup({
  capabilities = snip_caps,
  filetypes = {
    "css",
    "html",
    "javascriptreact",
    "less",
    "sass",
    "scss",
    "typescriptreact",
  },
})

Опция capabilities была использована для добавления сниппетов и предложений кода на основе языка программирования. Серверы, установленные выше, были Pyright для Python, PhpActor для PHP, TSServer для Javascript/TypeScript, Rust Analyzer для Rust и Emmet, чтобы сделать HTML и CSS/Sass авторинг более поддерживаемым.

Для работы языковых серверов необходимо, чтобы их исполняемые файлы присутствовали на машине. К счастью, расширение Neovim LSP Installer помогает в этом. Просто выполните команду :LSPInstallInfo и появится список нескольких серверов.

Диалог LSP Installer

Чтобы установить, просто нажмите i на имени нужного сервера.
Для обновления нажмите u. Для удаления нажмите x. Все очень наглядно, и если вы заблудитесь, просто нажмите ?, чтобы получить доступ к справке.

Почему не CoC?

Несмотря на то, что он очень полезен и гораздо проще в настройке, он медленнее. До написания этой статьи я использовал его ежедневно, а Neovim с LSP, настроенным на Lua, оказался гораздо более быстрым.

Возможно, причина в том, что CoC сделан на TypeScript и VimScript, языках более медленных, чем Lua.

Клавиатурные сокращения

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

---------------------------------
-- Key bindings
---------------------------------
local map = vim.api.nvim_set_keymap
local kmap = vim.keymap.set
local opts = { noremap = true, silent = true }

-- Leader
vim.g.mapleader = " "

-- Vim
map("n", "<F5>", ":Neotree toggle<CR>", opts)
map("n", "<C-q>", ":q!<CR>", opts)
map("n", "<F4>", ":bd<CR>", opts)
map("n", "<F6>", ":sp<CR>:terminal<CR>", opts)
map("n", "<S-Tab>", "gT", opts)
map("n", "<Tab>", "gt", opts)
map("n", "<silent> <Tab>", ":tabnew<CR>", opts)
map("n", "<C-p>", ':lua require("telescope.builtin").find_files()<CR>', opts)

-- Diagnostics
kmap("n", "<space>e", vim.diagnostic.open_float, opts)
kmap("n", "[d", vim.diagnostic.goto_prev, opts)
kmap("n", "]d", vim.diagnostic.goto_next, opts)
kmap("n", "<space>q", vim.diagnostic.setloclist, opts)

local on_attach = function(client, bufnr)
  -- Enable completion triggered by <c-x><c-o>
  vim.api.nvim_buf_set_option(bufnr, "omnifunc", "v:lua.vim.lsp.omnifunc")

  -- Mappings.
  local bufopts = { noremap = true, silent = true, buffer = bufnr }
  kmap("n", "gD", vim.lsp.buf.declaration, bufopts)
  kmap("n", "gd", vim.lsp.buf.definition, bufopts)
  kmap("n", "K", vim.lsp.buf.hover, bufopts)
  kmap("n", "gi", vim.lsp.buf.implementation, bufopts)
  kmap("n", "<C-k>", vim.lsp.buf.signature_help, bufopts)
  kmap("n", "<space>wa", vim.lsp.buf.add_workspace_folder, bufopts)
  kmap("n", "<space>wr", vim.lsp.buf.remove_workspace_folder, bufopts)
  kmap("n", "<space>wl", function()
    print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
  end, bufopts)
  kmap("n", "<space>D", vim.lsp.buf.type_definition, bufopts)
  kmap("n", "<space>rn", vim.lsp.buf.rename, bufopts)
  kmap("n", "<space>ca", vim.lsp.buf.code_action, bufopts)
  kmap("n", "gr", vim.lsp.buf.references, bufopts)
  kmap("n", "<space>f", vim.lsp.buf.formatting, bufopts)
end

Последние детали

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

Ошибки в виртуальном тексте

С помощью приведенного ниже кода ошибки отображаются в плавающих полях при наведении курсора на ошибку.

---------------------------------
-- Floating diagnostics message
---------------------------------
vim.diagnostic.config({
  float = { source = "always", border = border },
  virtual_text = false,
  signs = true,
})

---------------------------------
-- Auto commands
---------------------------------
vim.cmd([[ autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]])

Ошибка в плавающем поле

Если вас это не беспокоит, просто проигнорируйте эту часть.

Завершение

Готово! Этих строк достаточно, чтобы получить работающий Neovim с конфигурационным файлом на Lua.

Если вы в точности следовали тому, что было показано до сих пор, то ваш init.lua в итоге будет содержать около 380 строк, намного больше, чем версия на VimScript (154 строки, добавляя init.vim и coc-settings.json).

Честно говоря, я думал, что это будет более 500 строк, но мне удалось значительно сократить их количество. Этому способствовал тот факт, что я сделал это в одном файле, побудив меня оставить только самое необходимое. Я сделал это таким образом еще и потому, что до того момента, когда я пишу эти строки, я не нашел учебника, в котором использовался бы только один файл. Обычно в процессе работы создаются папки и папки с несколькими Lua-файлами, которые вызывают много путаницы в начале.

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

Если вы хотите ознакомиться с полным кодом, ниже есть ссылка на мой репозиторий .dotfiles.

До встречи!

Ссылки

• Эта статья на португальском языке
• Мои dotfiles
• Тема Sobrio

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