Recipes
Small programs built on pug-lint-parser. Each one runs as is with npm install pug-lint-parser in an ES module (.mjs, or "type": "module" in package.json).
List the classes a template uses
Classes come from .class shorthands and from static class="…" values. :class is a Vue binding and class=expr is Pug JavaScript, so neither is a list of names.
import { parsePug, walk } from 'pug-lint-parser'
const text = `nav.menu(class="dark wide")
a.item#home(href="/") Home
a(class="item", :class="{ active }") Docs
`
const doc = parsePug(text)
const classes = new Set()
walk(doc, (node) => {
if (node.type !== 'Tag') return
for (const s of node.shorthands) {
if (s.kind === 'class') classes.add(s.value)
}
for (const block of node.attributeBlocks) {
for (const attr of block.attributes) {
// Only static strings: `:class` is a Vue binding, `class=expr` is Pug JavaScript.
if (attr.key.raw !== 'class' || attr.value?.kind !== 'string') continue
for (const name of text.slice(...attr.value.inner).split(/\s+/)) {
if (name) classes.add(name)
}
}
}
})
console.log([...classes]) // [ 'menu', 'dark', 'wide', 'item' ]Rewrite quotes safely
A codemod edits the source by range, from the last edit to the first so earlier ranges stay valid. Then it checks its own output the way the ESLint plugin does: the result must parse and have the same fingerprint.
import { fingerprint, parsePug, walk } from 'pug-lint-parser'
/** Rewrite '…' attribute values as "…", unless the value contains a double quote. */
function doubleQuotes(text) {
const doc = parsePug(text)
if (doc.errors.length > 0) return text // never edit a template that does not parse
const edits = []
walk(doc, (node) => {
if (node.type !== 'Tag' && node.type !== 'MixinCall') return
for (const block of node.attributeBlocks) {
for (const { value } of block.attributes) {
if (value?.kind !== 'string' || value.quote !== "'") continue
const inner = text.slice(...value.inner)
if (inner.includes('"')) continue
edits.push({ range: value.range, text: `"${inner}"` })
}
}
})
// Apply from the end, so the earlier ranges stay valid.
let out = text
for (const { range, text: replacement } of edits.sort((a, b) => b.range[0] - a.range[0])) {
out = out.slice(0, range[0]) + replacement + out.slice(range[1])
}
// The same check the ESLint plugin makes: the structure must not change.
const after = parsePug(out)
if (after.errors.length > 0 || fingerprint(after) !== fingerprint(doc)) return text
return out
}
console.log(doubleQuotes(`a(href='/docs' title='Say "hi"') Docs\n`))
// a(href="/docs" title='Say "hi"') DocsCheck the template of a .vue file
Parse only the template's content with start and end; offsets still point into the whole file, so they turn into editor positions directly.
import { parsePug } from 'pug-lint-parser'
const sfc = `<template lang="pug">
div
p(class="oops) Hi
</template>
`
// Parse only the template's content; ranges and offsets still refer to the whole file.
const start = sfc.indexOf('>') + 1
const end = sfc.indexOf('</template>')
const doc = parsePug(sfc, { start, end })
for (const error of doc.errors) {
const before = sfc.slice(0, error.offset)
const line = before.split('\n').length
const column = error.offset - before.lastIndexOf('\n')
console.log(`${line}:${column} ${error.code}: ${error.message}`)
}
// 3:11 unterminated-string: Unterminated stringFind nodes of one kind
walk visits every node, with its parent. To find the Pug-only constructs a Vue template should not use, as the vue-pug/no-pug-control-flow rule does:
import { parsePug, walk } from 'pug-lint-parser'
const text = 'ul\n each item in items\n li= item\n'
walk(parsePug(text), (node) => {
if (node.type === 'Control' || node.type === 'Code') {
console.log(node.type, text.slice(...node.range))
}
})
// Control each item in items
// Code = item