Compare commits
3
Commits
01d0289091
...
22362ed393
| Author | SHA1 | Date | |
|---|---|---|---|
 danhanson
|
22362ed393 | ||
|
danhanson
|
9a254328f6 | ||
|
danhanson
|
1f556f6687 |
No files matched your search
@@ -138,7 +138,10 @@ arity, or whether a tag is a block tag. Two fallback rules accept them:
|
||||
|
||||
- `custom_tag` — `simpleTag($, $.identifier)`, i.e. what `simple_tag`/`inclusion_tag` accept, which is how
|
||||
a tag is registered unless it needs the parser itself.
|
||||
- the last alternative of `filter`, whose name is `$.identifier` rather than one of the builtin literals.
|
||||
- `_custom_filter`, the last alternative of `filter`, whose name is `$.identifier` rather than one of the
|
||||
builtin literals. Hidden, so the tree is what an inline alternative would give, but named so that a
|
||||
grammar extending this one can filter it out of `filter`'s `members` the way it can `custom_tag` — see
|
||||
the extension section in `README.md`.
|
||||
|
||||
**A name that only exists inside a tag group has to be reserved instead.** `endif`, `else`, `empty` and
|
||||
the rest are tokens only in the state their group opens, so where a tag is named the lexer reads them as an
|
||||
@@ -181,6 +184,14 @@ Modelling a library name makes it keyword-extracted, so it no longer reaches `cu
|
||||
registers its own tag under one of these names and a different signature therefore gets a parse error. That
|
||||
is accepted: these names are common enough that shadowing them is the mistake.
|
||||
|
||||
**Adding a library tag or filter touches four files**: `grammar.js`, `queries/libraries.scm` (which library
|
||||
it came from), `queries/highlights.scm` (the name, spelled out) and the table in `README.md`, which lists
|
||||
every library name the grammar models. All four are hand-maintained, and **no test catches a name left out
|
||||
of any of them**: `tree-sitter test` loads every `.scm` under `queries/`, so a pattern naming a node that
|
||||
no longer exists aborts the whole run, but a name that was never added passes 304/304 in silence, and the
|
||||
README nothing checks at all. The library-contents differential below, run against
|
||||
`django.templatetags.<name>.register`, is what finds a gap.
|
||||
|
||||
### External scanner (`src/scanner.c`)
|
||||
|
||||
Twelve external tokens, for the constraints a context-free grammar cannot express:
|
||||
@@ -269,8 +280,8 @@ Corpus tests live in `test/corpus/*.txt`, one file per tag.
|
||||
|
||||
### Checking against Django itself
|
||||
|
||||
The `Pipfile` pins Django so the grammar can be diffed against the real implementation instead of against
|
||||
documentation or memory. Both checks are worth repeating whenever tags, filters or literals change:
|
||||
`Pipfile.lock` pins Django (`Pipfile` itself says `django = "*"`) so the grammar can be diffed against the
|
||||
real implementation instead of against documentation or memory. Both checks are worth repeating whenever tags, filters or literals change:
|
||||
|
||||
- **Builtin parity** — enumerate `Engine.default_builtins`, then compare `register.tags` and
|
||||
`register.filters` against `grammar.js`. For filters also compare argument arity via
|
||||
@@ -288,8 +299,17 @@ documentation or memory. Both checks are worth repeating whenever tags, filters
|
||||
|
||||
### Deliberate divergences from Django
|
||||
|
||||
`README.md` carries a shorter list of its own, and the two are not the same set on purpose: the README
|
||||
lists only the divergences where Django accepts an input that is almost certainly a mistake, which is the
|
||||
rule it states. Anything added here that fits that rule belongs there too; anything that does not — an
|
||||
unavoidable limitation, or a case where this grammar is the more permissive one — stays here.
|
||||
|
||||
- Django has no number token: `[\w.]+` is one lexeme and `int()`/`float()` decides whether it is a literal,
|
||||
so `1a`, `1e`, `0x1f`, `1.2.3`, `1__0` and `1.` are variable _lookups_ there and errors here.
|
||||
so `1a`, `1e`, `0x1f`, `1.2.3`, `1__0` and `1.` are variable _lookups_ there and errors here. `1.` is the
|
||||
one that needs care: `Variable` calls `float()` and then rejects what it parsed if the last character is
|
||||
a dot (`# "2." is invalid`), so a trailing dot is a number only with an exponent after it — `1.e5` is a
|
||||
float and `1.` is not. The `number` regex is spelled to say that, and `test/corpus/template_variable.txt`
|
||||
pins all three.
|
||||
- Django has no boolean or `None` token either. `True`, `False` and `None` are lookups, which resolve
|
||||
because `BaseContext._reset_dicts` seeds every context with `{"True": True, "False": False, "None": None}`.
|
||||
They are `boolean` and `none` literals here, so that a tool reading `queries/locals.scm` does not count
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 Daniel Hanson
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -1,6 +1,35 @@
|
||||
# tree-sitter-django
|
||||
|
||||
A [tree-sitter](https://tree-sitter.github.io/tree-sitter/) grammar for the Django Template Language (DTL) — the `{% %}` tags and `{{ }}` variables used in Django templates.
|
||||
A [tree-sitter](https://tree-sitter.github.io/tree-sitter/) grammar for the Django Template Language (DTL) — the `{% %}` tags, `{{ }}` variables and `{# #}` comments used in Django templates.
|
||||
|
||||
## Coverage
|
||||
|
||||
Every tag and filter Django ships as a builtin is modelled — 28 tags and 57 filters as of Django 6.1 —
|
||||
and so is every tag and filter of the five libraries below. Arguments are part of the grammar rather than
|
||||
something a linter checks later, so a builtin written with the wrong ones is a parse error: `{{ x|length:2 }}`
|
||||
and `{% now %}` do not parse, because `length` takes no argument and `now` requires one.
|
||||
|
||||
The target is Django 6.1, including the builtins Django 6 added (`{% partial %}`, `{% partialdef %}`,
|
||||
`{% querystring %}`, `{% csp_nonce_attr %}`). Rather than being written from the documentation, the grammar
|
||||
is checked against a real Django — `Pipfile.lock` pins the version — by enumerating `Engine.default_builtins`
|
||||
for the tag and filter lists and their arities, and by running candidate snippets through both
|
||||
`django.template.Template()` and this parser to compare what each accepts. Where the two deliberately
|
||||
disagree is listed under [Divergences](#divergences-from-django).
|
||||
|
||||
## Using it
|
||||
|
||||
There is no published package yet, and no language bindings — those are coming. What is here today:
|
||||
|
||||
- **`src/parser.c` and `src/scanner.c` are generated and committed**, so any tree-sitter host can compile
|
||||
them directly without running the CLI. The scanner is required: block-name matching
|
||||
(`{% block a %}…{% endblock a %}`) and the repeated-argument guards live in it.
|
||||
- **`npm run parser-build`** produces `tree-sitter-django.wasm` for a `web-tree-sitter` host or an editor
|
||||
that loads Wasm grammars. It is a build artifact rather than a checked-in one, so it has to be built
|
||||
(or shipped by a release) before anything can load it.
|
||||
- **`queries/`** holds the highlight, locals, tags and injection queries an editor loads, plus three files
|
||||
meant for a linter. See [Queries](#queries).
|
||||
- **`tree-sitter.json`** names the grammar `django`, scopes it `source.django`, and points at the query
|
||||
files, which is what a tree-sitter host reads to wire all of the above together.
|
||||
|
||||
## Development
|
||||
|
||||
@@ -12,6 +41,194 @@ npm run parser-build # build the WASM binary
|
||||
npm run playground # interactively explore the grammar
|
||||
```
|
||||
|
||||
`src/parser.c`, `src/grammar.json` and `src/node-types.json` are generated **and committed**, so a change
|
||||
to `grammar.js` or `src/scanner.c` is only half made until `parser-generate` has run and the result is
|
||||
committed alongside it. `tree-sitter test` compiles the parser itself, so a stale `src/` shows up as tests
|
||||
that pass against the wrong grammar.
|
||||
|
||||
## Queries
|
||||
|
||||
Four of the files in `queries/` are the standard query files an editor loads:
|
||||
|
||||
- **`highlights.scm`** — syntax highlighting. Tag and filter names are listed one by one, so a name the
|
||||
grammar knows is captured as `@function` and a name it is only tolerating as `@function.call`.
|
||||
- **`locals.scm`** — scopes, definitions and references, so an editor can resolve a variable to the tag
|
||||
that bound it. A definition is a `variable:` field; the scopes are the clauses whose bindings do not
|
||||
outlive them (`{% with %}`, `{% for %}`, `{% empty %}`, `{% block %}`, `{% partialdef %}`,
|
||||
`{% blocktranslate %}`).
|
||||
- **`tags.scm`** — the symbol index behind `tree-sitter tag`. A `{% partialdef %}` and the names a
|
||||
`{% load %}` brings in are definitions; every tag and filter used is a reference.
|
||||
- **`injections.scm`** — marks template text and `{% verbatim %}` bodies as another language's content, so
|
||||
the HTML around the tags can be parsed by its own grammar. It names no language, leaving the editor to
|
||||
supply one.
|
||||
|
||||
The other three are data for a tool rather than queries an editor runs. Each captures the two halves of a
|
||||
relation a tree-sitter query cannot express, and the tool does the join:
|
||||
|
||||
- **`libraries.scm`** — which library each tag or filter is registered in, and what each `{% load %}`
|
||||
brings in. The grammar never requires the load, so reporting a missing one is a linter's job; a query
|
||||
has no ordering predicate to compare the positions itself.
|
||||
- **`exports.scm`** — a name a tag binds in the scope _around_ it rather than the scope it opens. Only
|
||||
`{% blocktranslate %}`'s `asvar` does that, and a locals query cannot say so: it places a definition in
|
||||
the innermost scope containing it and offers no way out again.
|
||||
- **`conditionals.scm`** — which bodies render on only some passes, as `@conditional.group` /
|
||||
`@conditional.branch` / `@conditional.default`, so a checker can tell that
|
||||
`{% if a %}{% now "Y" as n %}{% endif %}{{ n }}` may reach `{{ n }}` with nothing bound. A group is
|
||||
exhaustive exactly when one of its branches is a default. A locals query has no notion of a path not
|
||||
taken.
|
||||
|
||||
`tree-sitter test` loads every file in the directory, so a pattern naming a node that no longer exists
|
||||
fails the suite rather than quietly matching nothing.
|
||||
|
||||
## Django libraries
|
||||
|
||||
Five of Django's template libraries are not builtins: their names have to be `{% load %}`ed, or preloaded
|
||||
through the engine's `OPTIONS: {"builtins": [...]}`. Every tag and filter all five register is modelled,
|
||||
with the same argument and arity rules as a builtin:
|
||||
|
||||
| library | tags | filters |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
|
||||
| `i18n` | `trans`, `translate`, `blocktrans`, `blocktranslate`, `language`, `get_available_languages`, `get_current_language`, `get_current_language_bidi`, `get_language_info`, `get_language_info_list` | `language_bidi`, `language_name`, `language_name_local`, `language_name_translated` |
|
||||
| `l10n` | `localize` | `localize`, `unlocalize` |
|
||||
| `static` | `static`, `get_static_prefix`, `get_media_prefix` | — |
|
||||
| `cache` | `cache` | — |
|
||||
| `tz` | `localtime`, `timezone`, `get_current_timezone` | `localtime`, `timezone`, `utc` |
|
||||
|
||||
**The `{% load %}` is never required**, because an engine may have preloaded the library. Whether one is
|
||||
present is a question about the order of nodes rather than about how the template parses, so it is left to
|
||||
a tool: `queries/libraries.scm` marks each name with the library it came from and each `{% load %}` with
|
||||
what it brings in, and the tool joins the two. Such a tool needs to know that loading is positional
|
||||
(`{% trans "x" %}{% load i18n %}` is an error), that it is per file rather than inherited through
|
||||
`{% extends %}` or `{% include %}`, and that `{% load trans from i18n %}` brings in only the names it lists.
|
||||
|
||||
Because these names are modelled, they win over the fallbacks below: a project that registers its own tag
|
||||
under one of them with a different signature gets a parse error. They are common enough that shadowing
|
||||
them is treated as the mistake.
|
||||
|
||||
## Custom tags and filters
|
||||
|
||||
A library's tags and filters are registered in Python, so the grammar cannot know their names, their
|
||||
arity, or whether a tag opens a body. Two fallback rules accept them:
|
||||
|
||||
- **Tags.** Any tag the grammar does not recognise parses as `custom_tag`, with the shape `simple_tag` and
|
||||
`inclusion_tag` give: positional filter expressions, then `name=value` keyword arguments, then an
|
||||
optional `as name`. So `{% mytag a b|upper "s" k=1 as out %}` parses, with the name on the `tag:` field.
|
||||
A keyword argument written twice is refused, as `parse_bits` refuses it.
|
||||
- **Filters.** An unknown filter parses as `(filter name: (identifier))` with at most one `:argument`,
|
||||
which is all Django's expression regex allows. No arity check is possible.
|
||||
|
||||
Both are captured as `@function.call` rather than `@function`, so an editor can distinguish a name the
|
||||
grammar knows from one it is only tolerating.
|
||||
|
||||
What the fallbacks cannot do:
|
||||
|
||||
- **A block tag is not nested.** `{% mytag %}…{% endmytag %}` is two sibling `custom_tag`s; pairing them
|
||||
would mean guessing that an unknown tag opens a body.
|
||||
- **A tag registered with `@register.tag` may parse anything**, since it receives the raw token, so one
|
||||
whose arguments are not the `simple_tag` shape — `{% mytag <<>> %}` — is an error here and not in Django.
|
||||
- **A misspelled name cannot be caught.** `{{ x|lenght }}` is indistinguishable from a filter some library
|
||||
registered. Cross-referencing names against `{% load %}` needs the project's Python, so it belongs in a
|
||||
linter; `queries/libraries.scm` and the `load` rule supply what one needs.
|
||||
- **Names that only exist inside a tag group are reserved**, so `{% endif %}` or `{% empty %}` standing on
|
||||
its own is an error rather than a call to a custom tag of that name.
|
||||
|
||||
### Adding rules for your own tags and filters
|
||||
|
||||
For a project whose custom tags deserve real rules rather than the fallbacks, use this grammar as a base
|
||||
grammar. `grammar(base, {...})` merges your rules into it, and a rule that redefines one the base already
|
||||
has receives it as `previous`. A tag is an alternative of `template_block_groups`; a filter is an
|
||||
alternative of `filter`.
|
||||
|
||||
```js
|
||||
import django from "tree-sitter-django/grammar";
|
||||
|
||||
const SEP = /[ \t\r\n]+/;
|
||||
|
||||
export default grammar(django, {
|
||||
name: "djangox",
|
||||
|
||||
rules: {
|
||||
// {% map items over rows %}
|
||||
template_block_groups: ($, previous) => choice(previous, $.map_tag),
|
||||
map_tag: ($) =>
|
||||
seq(
|
||||
"{%",
|
||||
optional(SEP),
|
||||
"map",
|
||||
SEP,
|
||||
$.filtered_value,
|
||||
SEP,
|
||||
"over",
|
||||
SEP,
|
||||
$.filtered_value,
|
||||
optional(SEP),
|
||||
"%}",
|
||||
),
|
||||
|
||||
// {{ value|shout:"!" }}
|
||||
filter: ($, previous) =>
|
||||
choice(
|
||||
previous,
|
||||
seq(field("name", "shout"), ":", field("argument", $.value)),
|
||||
),
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
Five things to know:
|
||||
|
||||
- **Whitespace is explicit.** `extras` is empty, because Django splits a tag's contents before parsing any
|
||||
argument, so every separator has to be written out. The `part`/`block`/`simpleTag` helpers the base
|
||||
grammar is built from are private to it, hence the `SEP` above.
|
||||
- **A new name wins over the fallback.** `shout` becomes a token of its own, so it commits to your
|
||||
alternative and your arity applies — `{{ x|shout }}` is now an error, while names you have not modelled
|
||||
still fall through to `(filter name: (identifier))`.
|
||||
- **A tag with a body needs a `conflicts` entry**, as every clause in the base grammar does:
|
||||
`conflicts: ($, previous) => [...previous, [$.map_clause]]` for a `map_clause` holding the body. The
|
||||
generator offers an associativity
|
||||
instead; taking it silently discards the parse in which the body continues.
|
||||
- **End tags are not reserved**, a stray `{% endmap %}` parses as a `custom_tag` rather than an error — `reserved` takes no
|
||||
`previous`, so the `tag_name` list cannot be added to a name at a time. Instead you may drop the `custom_tag` rule to avoid parsing end tags as custom tags.
|
||||
- **The external scanner has to be re-exported under your grammar's name**, or block-name matching and the
|
||||
repeated-argument guards will not link. Give your grammar a `src/scanner.c` that renames the base's five entry points to the
|
||||
ones your generated `parser.c` calls, and includes it:
|
||||
|
||||
```c
|
||||
#define tree_sitter_django_external_scanner_create tree_sitter_djangox_external_scanner_create
|
||||
#define tree_sitter_django_external_scanner_destroy tree_sitter_djangox_external_scanner_destroy
|
||||
#define tree_sitter_django_external_scanner_scan tree_sitter_djangox_external_scanner_scan
|
||||
#define tree_sitter_django_external_scanner_serialize tree_sitter_djangox_external_scanner_serialize
|
||||
#define tree_sitter_django_external_scanner_deserialize tree_sitter_djangox_external_scanner_deserialize
|
||||
|
||||
#include "../node_modules/tree-sitter-django/src/scanner.c"
|
||||
```
|
||||
|
||||
The base's `tree_sitter/parser.h` then resolves to your own generated copy, and the externals keep the
|
||||
order they have here, so the scanner's token enum stays valid. `tree-sitter build` takes no include
|
||||
path, hence the relative `#include`; the package also exports `tree-sitter-django/src/scanner.c`, so a
|
||||
build step can hand the compiler an absolute path from `import.meta.resolve` where a package manager's
|
||||
layout makes the relative one unreliable.
|
||||
|
||||
**Turning the fallbacks off.** A grammar that models every tag and filter its project uses probably does
|
||||
not want `custom_tag` and `_custom_filter` accepting unrecognized names as they allow typos to parse. `previous` is the base rule whose `members` are filterable. We can filter out these rules to make the grammar more strict:
|
||||
|
||||
```js
|
||||
template_block_groups: ($, previous) =>
|
||||
choice(
|
||||
...previous.members.filter((m) => m.name !== "custom_tag"),
|
||||
$.map_tag,
|
||||
),
|
||||
|
||||
filter: ($, previous) =>
|
||||
choice(
|
||||
...previous.members.filter((m) => m.name !== "_custom_filter"),
|
||||
seq(field("name", "shout"), ":", field("argument", $.value)),
|
||||
),
|
||||
```
|
||||
|
||||
`{% mytag %}` and `{{ x|unknown }}` are then errors, while the builtins, the libraries and your own rules
|
||||
carry on as before.
|
||||
|
||||
## Divergences from Django
|
||||
|
||||
The grammar aims to accept what Django accepts, with one deliberate exception. Where Django takes an
|
||||
@@ -21,7 +238,8 @@ Every case below is input Django itself accepts:
|
||||
|
||||
- **Number-shaped names.** Django has no number token: a word is a literal if `int()` or `float()` parses
|
||||
it and a variable lookup otherwise, so `0x1f`, `1a`, `1.`, `1.2.3` and `1__0` look up a variable of that
|
||||
name and render nothing.
|
||||
name and render nothing. (`1.` really is a lookup there and not a float — `Variable` rejects a trailing
|
||||
dot after parsing it — while `1.e5` is a float, and both are treated that way here.)
|
||||
- **An attribute of `True`, `False` or `None`.** Every Django context is seeded with those three names, so
|
||||
`{{ True.x }}` is an ordinary two-part lookup that can never resolve.
|
||||
- **A keyword argument written twice.** `{% with a=1 a=2 %}`, and the same in `{% include %}` and
|
||||
@@ -33,6 +251,9 @@ Every case below is input Django itself accepts:
|
||||
in that position, so `{% cache 500 using="c" %}` names a fragment called `using="c"` rather than choosing
|
||||
a cache, and `{% cache 500 sidebar.name %}` names one with a dot in it.
|
||||
|
||||
In the other direction the grammar is more permissive only where it cannot know better: the names a
|
||||
`{% load %}` brings in live in Python, so `{{ x|lenght }}` cannot be told from a filter some library
|
||||
registered, and an unknown tag's arguments are assumed to have the shape `simple_tag` gives them.
|
||||
In the other direction the grammar is more permissive only where it cannot know better, which is what the
|
||||
fallbacks above are for.
|
||||
|
||||
## License
|
||||
|
||||
MIT — see [LICENSE](LICENSE).
|
||||
+20
-6
@@ -395,10 +395,17 @@ const django = grammar({
|
||||
value: ($) => choice($.literal, $.variable_attribute),
|
||||
literal: ($) =>
|
||||
choice($.number, $.string, $.translated_string, $.boolean, $.none),
|
||||
// digits, with single underscores allowed between them, as Python's
|
||||
// int() and float() accept ("1_000") and Django's Variable relies on
|
||||
/**
|
||||
* Digits, with single underscores allowed between them, as Python's int()
|
||||
* and float() accept ("1_000") and Django's Variable relies on.
|
||||
*
|
||||
* A trailing dot needs an exponent after it. Variable calls float() and
|
||||
* then rejects what it just parsed if the last character is a dot — the
|
||||
* comment in Django reads `# "2." is invalid` — so "1." is a two-part
|
||||
* lookup there rather than a number, while "1.e5" is a float.
|
||||
*/
|
||||
number: ($) =>
|
||||
/[-+]?(?:[0-9](?:_?[0-9])*(?:\.(?:[0-9](?:_?[0-9])*)?)?|\.[0-9](?:_?[0-9])*)(?:[eE][0-9](?:_?[0-9])*)?/,
|
||||
/[-+]?(?:(?:[0-9](?:_?[0-9])*(?:\.[0-9](?:_?[0-9])*)?|\.[0-9](?:_?[0-9])*)(?:[eE][0-9](?:_?[0-9])*)?|[0-9](?:_?[0-9])*\.[eE][0-9](?:_?[0-9])*)/,
|
||||
string: ($) => STRING,
|
||||
/**
|
||||
* A string to translate at render time. Django matches "_(" and ")" as
|
||||
@@ -549,13 +556,20 @@ const django = grammar({
|
||||
field("name", choice(...FILTERS_WITH_OPTIONAL_ARGUMENT)),
|
||||
optional(seq(":", field("argument", $.value))),
|
||||
),
|
||||
// a filter a "load" brought in: its name is not known here, and so
|
||||
// neither is whether it takes an argument
|
||||
$._custom_filter,
|
||||
),
|
||||
/**
|
||||
* A filter a "load" brought in: its name is not known here, and so neither
|
||||
* is whether it takes an argument. Hidden, so the tree is the same as if
|
||||
* it were spelled inline, but named so that a grammar extending this one
|
||||
* can drop it from filter's alternatives the way it can drop custom_tag
|
||||
* from template_block_groups.
|
||||
*/
|
||||
_custom_filter: ($) =>
|
||||
seq(
|
||||
field("name", $.identifier),
|
||||
optional(seq(":", field("argument", $.value))),
|
||||
),
|
||||
),
|
||||
autoescape_clause: ($) =>
|
||||
seq(block("autoescape", part(choice("on", "off"))), optional($.template)),
|
||||
autoescape_group: ($) => seq($.autoescape_clause, block("endautoescape")),
|
||||
|
||||
@@ -4,6 +4,12 @@
|
||||
"private": true,
|
||||
"license": "MIT",
|
||||
"type": "module",
|
||||
"exports": {
|
||||
"./grammar": "./grammar.js",
|
||||
"./src/scanner.c": "./src/scanner.c",
|
||||
"./queries/*": "./queries/*",
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint",
|
||||
"lint:fix": "eslint --fix",
|
||||
|
||||
+7
-3
@@ -135,7 +135,7 @@
|
||||
},
|
||||
"number": {
|
||||
"type": "PATTERN",
|
||||
"value": "[-+]?(?:[0-9](?:_?[0-9])*(?:\\.(?:[0-9](?:_?[0-9])*)?)?|\\.[0-9](?:_?[0-9])*)(?:[eE][0-9](?:_?[0-9])*)?"
|
||||
"value": "[-+]?(?:(?:[0-9](?:_?[0-9])*(?:\\.[0-9](?:_?[0-9])*)?|\\.[0-9](?:_?[0-9])*)(?:[eE][0-9](?:_?[0-9])*)?|[0-9](?:_?[0-9])*\\.[eE][0-9](?:_?[0-9])*)"
|
||||
},
|
||||
"string": {
|
||||
"type": "PATTERN",
|
||||
@@ -1313,6 +1313,12 @@
|
||||
]
|
||||
},
|
||||
{
|
||||
"type": "SYMBOL",
|
||||
"name": "_custom_filter"
|
||||
}
|
||||
]
|
||||
},
|
||||
"_custom_filter": {
|
||||
"type": "SEQ",
|
||||
"members": [
|
||||
{
|
||||
@@ -1349,8 +1355,6 @@
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"autoescape_clause": {
|
||||
"type": "SEQ",
|
||||
|
||||
+43883
-43744
File diff suppressed because it is too large.
Load diff
@@ -461,3 +461,40 @@ Template Variable Attribute Of A Literal
|
||||
|
||||
---
|
||||
|
||||
|
||||
==================
|
||||
Template Variable Trailing Dot With An Exponent
|
||||
==================
|
||||
|
||||
{{ 1.e5 }}
|
||||
|
||||
---
|
||||
|
||||
(template
|
||||
(content)
|
||||
(template_variable
|
||||
(filtered_value
|
||||
(value
|
||||
(literal
|
||||
(number)))))
|
||||
(content))
|
||||
|
||||
==================
|
||||
Template Variable Trailing Dot
|
||||
:error
|
||||
==================
|
||||
|
||||
{{ 1. }}
|
||||
|
||||
---
|
||||
|
||||
|
||||
==================
|
||||
Template Variable Signed Trailing Dot
|
||||
:error
|
||||
==================
|
||||
|
||||
{{ -1. }}
|
||||
|
||||
---
|
||||
|
||||
Reference in new issue
Block a user