Przejdź do głównej zawartości

Integracje

Niezależnie od edytora zainstaluj djLint tam, gdzie edytor może go znaleźć, najlepiej w środowisku wirtualnym projektu, a następnie uruchamiaj edytor z tego środowiska albo wskaż mu djlint z tego środowiska. Dzięki temu edytor uruchamia wersję przypiętą w projekcie i daje takie same wyniki jak hook pre-commit czy CI.

Jeśli projekt instaluje djLint przez npm, jego polecenie to node_modules/.bin/djlint w projekcie, a na Windows node_modules\.bin\djlint.cmd. Tam, gdzie edytor poniżej uruchamia djlint, podaj mu tę ścieżkę. Rozszerzenia dla VS Code i Zed znajdą go same.

Zainstaluj rozszerzenie djLint z Visual Studio Marketplace. Cursor, Windsurf, VSCodium i inne edytory oparte na VS Code instalują to samo rozszerzenie z Open VSX. Rozszerzenie znajduje djLint w twoim środowisku, a gdy go tam nie ma, korzysta z dołączonej wersji; jeśli twój djLint ma serwer języka, rozszerzenie go używa.

Jego README opisuje ustawienia rozszerzenia i to, którego djLint ono uruchamia.

Rozszerzenie djLint uruchamia serwer języka w HTML i w językach rozszerzeń szablonów, takich jak Django, Jinja i Twig. Nie ma go jeszcze w rejestrze rozszerzeń Zeda, więc zainstaluj je jako rozszerzenie deweloperskie:

  1. Zainstaluj Rusta przez rustup: Zed buduje nim rozszerzenie i sam dodaje target wasm32-wasip2. Z Rustem z innego źródła, na przykład z Homebrew albo Nixa, dodaj go samodzielnie.

  2. Sklonuj rozszerzenie:

    Okno terminala
    git clone https://github.com/djlint/djlint-zed
  3. W Zedzie otwórz paletę poleceń (cmd-shift-p na macOS, gdzie indziej ctrl-shift-p), uruchom zed: install dev extension i wybierz sklonowany folder djlint-zed.

Aby je zaktualizować, uruchom w tym folderze git pull, a potem zed: rebuild dev extension.

Potrzebuje djLinta 1.49 lub nowszego w PATH lub zainstalowanego w projekcie przez npm albo uv, które uruchamia djLinta bez instalacji. Jego README pokazuje, jak ustawić je jako formater języka, i opisuje jego ustawienia.

Niektórym rozszerzeniom szablonów Neovim nie nadaje typu pliku. Niezależnie od tego, której opcji poniżej używasz, najpierw je zarejestruj:

vim.filetype.add({
extension = {
gohtml = "gotmpl", gotmpl = "gotmpl", handlebars = "handlebars",
j2 = "jinja", jinja2 = "jinja", mako = "mako", njk = "nunjucks",
},
})

Neovim 0.11 lub nowszy może komunikować się z serwerem języka djLint bezpośrednio, bez żadnej wtyczki. Daje to zgłoszenia już podczas pisania, z podkreślonymi zakresami, oraz formatowanie przez vim.lsp.buf.format():

vim.lsp.config("djlint", {
cmd = { "djlint", "--lsp" },
filetypes = {
"html", "htmldjango", "htmlangular", "jinja", "jinja.html", "nunjucks",
"twig", "handlebars", "mustache", "liquid", "gotmpl", "tera", "mako",
},
root_markers = { "pyproject.toml", "djlint.toml", ".djlint.toml", ".djlintrc", ".git" },
})
vim.lsp.enable("djlint")

Aby formatować przy zapisie, dodaj do tej samej konfiguracji:

local group = vim.api.nvim_create_augroup("djlint_format", {})
vim.api.nvim_create_autocmd("LspAttach", {
callback = function(args)
if vim.lsp.get_client_by_id(args.data.client_id).name ~= "djlint" then
return
end
vim.api.nvim_clear_autocmds({ group = group, buffer = args.buf })
vim.api.nvim_create_autocmd("BufWritePre", {
group = group,
buffer = args.buf,
callback = function()
vim.lsp.buf.format({ bufnr = args.buf, name = "djlint" })
end,
})
end,
})

Zobacz Ustawienia.

conform.nvim formatuje, a nvim-lint lintuje, uruchamiając djLint jako polecenie. Zgłoszenia nie mają podkreślonego zakresu i pojawiają się dopiero wtedy, gdy poprosisz nvim-lint o lintowanie. Profil pochodzi z konfiguracji projektu, tak jak w wierszu poleceń. Ten przykład wymaga djLint 1.49 lub nowszego.

local formatters, linters = {}, {}
for _, filetype in ipairs({
"html", "htmldjango", "htmlangular", "jinja", "jinja.html", "nunjucks",
"twig", "handlebars", "mustache", "liquid", "gotmpl", "tera", "mako",
}) do
formatters[filetype] = { "djlint" }
linters[filetype] = { "djlint" }
end
require("conform").setup({
formatters_by_ft = formatters,
formatters = { djlint = { prepend_args = { "--stdin-filename", "$FILENAME" } } },
})
local lint = require("lint")
lint.linters_by_ft = linters
vim.list_extend(lint.linters.djlint.args, {
"--stdin-filename",
function()
return vim.api.nvim_buf_get_name(0)
end,
})

W PyCharmie i innych IDE opartych na IntelliJ użyj darmowej wtyczki LSP4IJ:

  1. Zainstaluj LSP4IJ z Marketplace.

  2. Otwórz okno narzędziowe LSP Consoles i dodaj nowy serwer języka.

  3. Na karcie Server ustaw nazwę djLint i polecenie djlint --lsp, z pełną ścieżką do djlint ze środowiska wirtualnego projektu, jeśli nie ma go w PATH.

  4. Na karcie Mappings dodaj wzorce nazw plików swoich szablonów. Jeśli konfiguracja projektu nie zawiera profilu, wybiera go identyfikator języka przy wzorcu:

    Wzorce Identyfikator języka
    *.html, *.htm html, w Django htmldjango
    *.jinja, *.jinja2, *.j2 jinja
    *.njk, *.twig nunjucks
    *.hbs, *.handlebars, *.mustache handlebars
    *.liquid liquid
    *.gotmpl, *.gohtml gotmpl
    *.tera tera
    *.mako mako
  5. Na karcie Configuration możesz podać ustawienia w formacie JSON, pod kluczem djlint.

Zgłoszenia pojawiają się w edytorze, a Reformat Code może używać serwera dla zmapowanych plików.

Pakiet LSP uruchamia serwer języka, który zapewnia zgłoszenia podczas pisania oraz formatowanie.

Uruchom Preferences: LSP Server Configurations i dodaj:

{ "djlint": { "enabled": true, "command": ["djlint", "--lsp"], "selector": "text.html" } }

Zainstaluj SublimeLinter i SublimeLinter-contrib-djlint przez Package Control. djLint musi być w PATH widocznym dla Sublime Text.

Helix może uruchamiać serwer języka skonfigurowany w languages.toml. Lista language-servers zastępuje tę, którą Helix ma dla danego języka, więc po djlint zostaw jego własne serwery:

[language-server.djlint]
command = "djlint"
args = ["--lsp"]
[[language]]
name = "html"
language-servers = ["djlint", "vscode-html-language-server", "superhtml"]
[[language]]
name = "htmldjango"
language-servers = ["djlint", "djlsp", "vscode-html-language-server", "superhtml"]
[[language]]
name = "gotmpl"
language-servers = ["djlint", "gopls"]
[[language]]
name = "jinja"
language-servers = ["djlint"]
[[language]]
name = "nunjucks"
language-servers = ["djlint"]
[[language]]
name = "twig"
language-servers = ["djlint"]
[[language]]
name = "tera"
language-servers = ["djlint"]

Helix sam nie otwiera żadnego pliku jako htmldjango. W projekcie Django dodaj file-types = ["html"] do tego wpisu w pliku .helix/languages.toml projektu.

Eglot, dostarczany z Emacsem 29 i nowszymi:

(with-eval-after-load 'eglot
(dolist (mode '(html-mode mhtml-mode web-mode jinja2-mode twig-mode
handlebars-mode mustache-mode))
(add-to-list 'eglot-server-programs `(,mode . ("djlint" "--lsp")))))

Następnie uruchom M-x eglot w szablonie. eglot-format-buffer go sformatuje. html-mode, mhtml-mode i web-mode nie wskazują języka szablonów, więc w nich profil pochodzi z konfiguracji projektu.

djlint --lsp uruchamia djLint jako serwer języka komunikujący się przez stdio. Serwer działa bez przerwy, więc edytor dostaje zgłoszenia podczas pisania i formatuje dokument bez każdorazowego uruchamiania nowego procesu.

Serwer przekazuje zgłoszenia i formatuje całe dokumenty. Nie wymaga dodatkowych pakietów. Każdy inny edytor obsługujący LSP może go uruchomić tym samym poleceniem.

Serwer wczytuje konfigurację projektu tak samo jak wiersz poleceń: od folderu każdego pliku w górę. Ustawienia z edytora mają przed nią pierwszeństwo, ale tak jak w wierszu poleceń mogą jedynie włączyć opcję lub ustawić wartość: false nie wyłącza tego, co włącza projekt. Mają nazwy opcji wiersza poleceń, zapisane z podkreśleniami lub w camelCase, a wartości oddzielane przecinkami można podawać jako listy:

vim.lsp.config("djlint", {
settings = { djlint = { profile = "django", ignore = { "H013", "H016" } } },
})

Serwer pobiera sekcję djlint przez workspace/configuration. Edytor, który nie potrafi na to odpowiedzieć, może wysłać te same klucze w initializationOptions.

Dwa ustawienia nie mają odpowiednika w wierszu poleceń:

  • use_editor_indentation: formatowanie z rozmiarem tabulacji ustawionym w edytorze zamiast indent.
  • python_rules: ustaw na false, aby pominąć własne reguły z python_module, dzięki czemu kod projektu nie zostanie uruchomiony.

djLint bierze profile z pierwszego z tych źródeł, które go zawiera:

  1. Ustawienia edytora.
  2. Konfiguracja projektu.
  3. Język dokumentu: na przykład dla htmldjango uruchamiany jest profil django.

Jeśli żadne z nich go nie zawiera, djLint działa bez profilu, tak jak w wierszu poleceń. profile w konfiguracji projektu to najprostsze rozwiązanie: działa w każdym edytorze i nie wymaga ustawiania identyfikatora języka.

  • Zgłoszenia pojawiają się po krótkiej przerwie w pisaniu. Edytor obsługujący diagnostykę typu pull sam o nie prosi, a każdy inny dostaje je w trybie push.
  • exclude, extend_exclude i use_gitignore dotyczą otwartych dokumentów. Wykluczony dokument nie ma zgłoszeń i nie jest formatowany.
  • Serwer ponownie wczytuje konfigurację, gdy zmieni się pyproject.toml, djlint.toml, .djlint.toml, .djlintrc, .djlint_rules.yaml, .editorconfig lub .gitignore, jeśli edytor potrafi obserwować pliki, a w przeciwnym razie przy otwarciu lub zapisaniu dokumentu. Pliki wskazane przez configuration lub rules są wczytywane ponownie przy otwarciu lub zapisaniu dokumentu. Zmiana kodu w python_module własnej reguły wymaga ponownego uruchomienia serwera.
  • Powolna reguła wstrzymuje wszystko, co przychodzi po niej, ponieważ serwer robi tylko jedną rzecz naraz.

W workflow GitHub Actions djLint zgłasza każdy problem jako adnotację, dzięki czemu jest on widoczny bezpośrednio w diffie pull requesta. Nie trzeba niczego konfigurować: djLint wykrywa workflow i automatycznie przełącza format wyjścia.

- run: pip install djlint
- run: djlint . --lint --profile django

Użyj --no-github-output, aby zamiast tego otrzymać zwykłe wyjście konsoli, lub --github-output, aby wymusić adnotacje poza Actions.

Adnotacje należą do jednego pull requesta. Aby przechowywać zgłoszenia na karcie Security repozytorium, wraz z historią kolejnych uruchomień, zapisz je w formacie SARIF i prześlij plik:

- run: djlint . --lint --sarif > djlint.sarif
continue-on-error: true
- uses: github/codeql-action/upload-sarif@v4
with:
sarif_file: djlint.sarif

Krok przesyłania wymaga uprawnienia security-events: write dla zadania lub workflow.

--sarif zapisuje na stdout dokument SARIF 2.1.0 i nic więcej, więc można go przekierować tak jak powyżej. Każda włączona reguła jest wymieniona wraz z linkiem do swojej dokumentacji, każde zgłoszenie zawiera wiersz i kolumnę, a przy --check plik, który zostałby przeformatowany, jest zgłaszany pod regułą formatting.

djLint może działać jako hook pre-commit, zarówno jako linter, jak i formater.

Każdy z tych profili ma hook lintujący, wymieniony poniżej, i hook formatujący o tej samej nazwie z reformat: djlint-reformat-django dla djlint-django. Ustawiają --profile i pliki, które przekazuje pre-commit. angular nie ma własnych hooków: ustaw dla djlint lub djlint-reformat args: [--profile=angular].

Hook Profil Pliki
djlint brak .html, .htm, .xhtml
djlint-django django .html, .htm, .xhtml
djlint-jinja jinja .j2, .jinja, .jinja2
djlint-nunjucks nunjucks .njk
djlint-handlebars handlebars .hbs, .handlebars, .mustache
djlint-liquid liquid .html, .htm, .xhtml, .liquid
djlint-golang golang .gotmpl
djlint-tera tera .html, .htm, .xhtml
djlint-askama askama .html, .htm, .xhtml
djlint-mako mako .html, .htm, .xhtml

Dla szablonów z innymi rozszerzeniami nadpisz w swojej konfiguracji files, a także types_or, jeśli hook je ustawia, bo pre-commit wymaga dopasowania obu. Zobacz dokumentację pre-commit.

repos:
- repo: https://github.com/djlint/djLint
rev: v1.54.0
hooks:
- id: djlint-reformat-django
- id: djlint-django
repos:
- repo: https://github.com/djlint/djLint
rev: v1.54.0
hooks:
- id: djlint-reformat-handlebars
files: "\\.html"
types_or: ["html"]
- id: djlint-handlebars
files: "\\.html"
types_or: ["html"]

Za pomocą parametrów files lub exclude możesz ograniczyć każdy hook do jego własnego katalogu, co pozwala obsługiwać kilka języków szablonów w jednym repozytorium.

MegaLinter zawiera djLint. Aby go skonfigurować, uruchom npx mega-linter-runner --install, a opcje znajdziesz na jego stronie o djLint.