Salta ai contenuti

Integrazioni

Qualunque editor tu usi, installa djLint dove l’editor può trovarlo, idealmente nell’ambiente virtuale del progetto, e avvia l’editor da lì oppure indicagli il djlint di quell’ambiente. In questo modo l’editor esegue la versione fissata dal progetto, con gli stessi risultati del tuo hook di pre-commit o della CI.

Se il progetto installa djLint con npm, il suo comando è node_modules/.bin/djlint nel progetto, oppure node_modules\.bin\djlint.cmd su Windows. Dove un editor qui sotto esegue djlint, indicagli quel percorso. Le estensioni per VS Code e Zed lo trovano da sole.

Installa l’estensione djLint dal Visual Studio Marketplace. Cursor, Windsurf, VSCodium e gli altri editor basati su VS Code installano la stessa estensione da Open VSX. Trova djLint nel tuo ambiente, in mancanza usa una copia inclusa nell’estensione e usa il server di linguaggio quando il tuo djLint lo offre.

Il suo README descrive le impostazioni e quale djLint esegue.

L’estensione djLint esegue il server di linguaggio in HTML e nei linguaggi delle estensioni per i template, come Django, Jinja e Twig. Non è ancora nel registro delle estensioni di Zed, quindi installala come estensione di sviluppo:

  1. Installa Rust con rustup: Zed compila l’estensione con esso e aggiunge da solo il target wasm32-wasip2. Con un Rust installato in altro modo, ad esempio con Homebrew o Nix, aggiungilo tu.

  2. Clona l’estensione:

    Finestra del terminale
    git clone https://github.com/djlint/djlint-zed
  3. In Zed, apri la palette dei comandi (cmd-shift-p su macOS, ctrl-shift-p altrove), esegui zed: install dev extension e scegli la cartella clonata djlint-zed.

Per aggiornarla, esegui git pull in quella cartella e poi zed: rebuild dev extension.

Serve djLint 1.49 o successivo nel PATH o installato nel progetto con npm, oppure uv, che esegue djLint senza installarlo. Il suo README spiega come renderla il formattatore di un linguaggio e descrive le sue impostazioni.

Neovim non assegna un filetype ad alcune estensioni dei template. Qualunque opzione qui sotto usi, registrale prima:

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

Neovim 0.11 o successivo può comunicare direttamente con il server di linguaggio di djLint, senza plugin. Così ottieni le segnalazioni mentre scrivi, con gli intervalli sottolineati, e vim.lsp.buf.format() per la formattazione:

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")

Per formattare al salvataggio, aggiungi questo alla stessa configurazione:

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,
})

Vedi Impostazioni.

conform.nvim formatta e nvim-lint esegue il lint, avviando djLint come comando. Le segnalazioni non hanno un intervallo sottolineato e arrivano solo quando chiedi a nvim-lint di eseguire il lint. Il profilo viene dalla configurazione del progetto, come da riga di comando. Questo esempio richiede djLint 1.49 o successivo.

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,
})

In PyCharm e negli altri IDE basati su IntelliJ, usa il plugin gratuito LSP4IJ:

  1. Installa LSP4IJ dal Marketplace.

  2. Apri la finestra degli strumenti LSP Consoles e aggiungi un nuovo server di linguaggio.

  3. Nella scheda Server, imposta il nome su djLint e il comando su djlint --lsp, con il percorso completo del djlint presente nell’ambiente virtuale del progetto se non è nel PATH.

  4. Nella scheda Mappings, aggiungi i pattern di nomi di file dei tuoi template. Se la configurazione del progetto non ha un profilo, lo sceglie l’ID del linguaggio di ciascun pattern:

    Pattern ID del linguaggio
    *.html, *.htm html, o htmldjango con Django
    *.jinja, *.jinja2, *.j2 jinja
    *.njk, *.twig nunjucks
    *.hbs, *.handlebars, *.mustache handlebars
    *.liquid liquid
    *.gotmpl, *.gohtml gotmpl
    *.tera tera
    *.mako mako
  5. Nella scheda Configuration puoi indicare le impostazioni in JSON, sotto una chiave djlint.

Le segnalazioni compaiono nell’editor e Reformat Code può usare il server per i file mappati.

Il pacchetto LSP esegue il server di linguaggio, che fornisce le segnalazioni mentre scrivi e la formattazione.

Esegui Preferences: LSP Server Configurations e aggiungi:

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

Installa SublimeLinter e SublimeLinter-contrib-djlint con Package Control. djLint deve trovarsi nel PATH che vede Sublime Text.

Helix può eseguire il server di linguaggio da languages.toml. Un elenco language-servers sostituisce quello che Helix ha per quel linguaggio, quindi tieni i suoi server dopo djlint:

[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 da solo non apre nessun file come htmldjango. In un progetto Django, aggiungi file-types = ["html"] a quella voce nel .helix/languages.toml del progetto.

Eglot, incluso in Emacs 29 e versioni successive:

(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")))))

Poi esegui M-x eglot in un template. eglot-format-buffer lo formatta. html-mode, mhtml-mode e web-mode non indicano alcun linguaggio di template, quindi lì il profilo viene dalla configurazione del progetto.

djlint --lsp esegue djLint come server di linguaggio su stdio. Resta in esecuzione, così un editor riceve le segnalazioni mentre scrivi e formatta un documento senza avviare ogni volta un processo.

Fornisce le segnalazioni e formatta documenti interi. Non richiede pacchetti aggiuntivi. Qualsiasi altro editor che supporta LSP può eseguirlo con lo stesso comando.

Il server legge la configurazione del progetto come fa la riga di comando, risalendo dalla cartella di ciascun file. Le impostazioni dell’editor hanno la precedenza su di essa ma, come sulla riga di comando, possono solo attivare un’opzione o impostare un valore: false non disattiva ciò che il progetto attiva. Usano i nomi delle opzioni della riga di comando, con i trattini bassi o in camelCase, e per i valori separati da virgole si possono usare delle liste:

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

Il server richiede la sezione djlint con workspace/configuration. Un editor che non può rispondere può inviare le stesse chiavi in initializationOptions.

Due impostazioni non hanno un’opzione della riga di comando:

  • use_editor_indentation: formatta con la dimensione della tabulazione dell’editor, invece di indent.
  • python_rules: impostala su false per saltare le regole personalizzate con un python_module, così il codice del progetto non viene eseguito.

djLint prende il profile dalla prima di queste fonti che ne indica uno:

  1. Le impostazioni dell’editor.
  2. La configurazione del progetto.
  3. Il linguaggio del documento: htmldjango esegue il profilo django, ad esempio.

Se nessuna lo indica, djLint viene eseguito senza profilo, come sulla riga di comando. Un profile nella configurazione del progetto è la scelta più semplice: funziona in ogni editor, senza dover impostare alcun ID di linguaggio.

  • Le segnalazioni arrivano dopo una breve pausa nella digitazione. Un editor con diagnostica pull le richiede, a qualsiasi altro vengono inviate in push.
  • exclude, extend_exclude e use_gitignore si applicano ai documenti aperti. Un documento escluso non ha segnalazioni e non viene formattato.
  • Ricarica la configurazione quando cambiano pyproject.toml, djlint.toml, .djlint.toml, .djlintrc, .djlint_rules.yaml, .editorconfig o .gitignore, se l’editor è in grado di monitorare i file, e altrimenti quando un documento viene aperto o salvato. I file indicati da configuration o rules vengono riletti quando un documento viene aperto o salvato. Una modifica al codice del python_module di una regola personalizzata richiede un riavvio.
  • Una regola lenta fa attendere ciò che viene dopo, perché il server fa una cosa alla volta.

In un workflow di GitHub Actions djLint riporta ogni segnalazione come annotazione, che compare quindi inline nel diff di una pull request. Non serve alcuna configurazione: djLint rileva il workflow e cambia automaticamente l’output.

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

Usa --no-github-output per ottenere invece il normale output della console, oppure --github-output per forzare le annotazioni al di fuori di Actions.

Le annotazioni restano legate a una singola pull request. Per conservare le segnalazioni nella scheda Security del repository, con la cronologia tra un’esecuzione e l’altra, scrivile in formato SARIF e carica il file:

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

Il passaggio di caricamento richiede il permesso security-events: write sul job o sul workflow.

--sarif scrive su stdout un documento SARIF 2.1.0 e nient’altro, quindi può essere reindirizzato come sopra. Ogni regola attiva è elencata con un link alla sua documentazione, ogni segnalazione riporta la sua riga e colonna e, con --check, un file che verrebbe riformattato viene segnalato sotto una regola formatting.

djLint può essere usato come hook di pre-commit, sia come linter sia come formattatore.

Ognuno di questi profili ha un hook che esegue il lint, elencato qui, e uno che formatta, con lo stesso nome più reformat: djlint-reformat-django per djlint-django. Impostano --profile e i file che pre-commit passa. angular non ha hook propri: aggiungi args: [--profile=angular] a djlint o djlint-reformat.

Hook Profilo File
djlint nessuno .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

Per template con altre estensioni, sovrascrivi files nella tua configurazione, e anche types_or dove l’hook lo imposta, perché pre-commit richiede che corrispondano entrambi. Vedi la documentazione di 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"]

Puoi usare i parametri files o exclude per limitare ciascun hook alla propria directory, così da supportare più linguaggi di template nello stesso repository.

MegaLinter include djLint. Esegui npx mega-linter-runner --install per configurarlo e consulta la sua pagina su djLint per le opzioni.