dtab 0.2.0__tar.gz → 0.3.0__tar.gz

{dtab-0.2.0 → dtab-0.3.0}/PKG-INFO

@@ -1,13 +1,18 @@
 Metadata-Version: 2.4
 Name: dtab
-Version: 0.2.0
+Version: 0.3.0
 Summary: Delta Tab: config files made of tab-separated paths. One line is one path into a tree.
 Project-URL: Homepage, https://github.com/RyannDaGreat/dtab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: fire
 
-<p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p>
+<!-- <p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p> -->
+<!-- <img width="6912" height="4188" alt="image" src="https://github.com/user-attachments/assets/db10af67-b7ba-4e42-a808-946c8cdcc2c7" /> -->
+<img width="6912" height="2940" alt="image" src="https://github.com/user-attachments/assets/24f2187b-9e71-45e6-9a4b-427ad00e48c8" />
+
+
+
 <p align="center"><sub>Logo made with <a href="https://github.com/RyannDaGreat/SvelteLib">PowerRP</a>. <a href="https://ryanndagreat.github.io/SvelteLib/?repo=RyannDaGreat/dtab">Open it in PowerRP</a> to edit it (source: <code>assets/doc.json</code>).</sub></p>
 
 # dtab
@@ -32,7 +37,7 @@ dtab.parse(open("scene.dtab").read())
 
 - Less to look at. No braces, quotes, or commas between values. A file with its tabs aligned reads like pseudocode, and is easy to write by hand, even on paper.
 - Simple. Six rules, one pass, about 70 lines per implementation.
-- Everything is addressable. There are no lists, so every value has a dotted path: `config.deltas.l1.position.x` works with EasyDict in Python and plain property access in JavaScript.
+- Everything is addressable. There are no lists, so every value has a path: `config.deltas.l1.position.x` with EasyDict in Python or plain property access in JavaScript, brackets for keys like `file.json`.
 - You choose the shape. Lines stack, and `c,d` writes one value under several keys, so the same tree can be written wide, deep, or on one line, trading horizontal space for vertical. These are the same file:
 
   ```
@@ -59,8 +64,9 @@ dtab.parse(open("scene.dtab").read())
 - An entry that starts with a space is a comment.
 - `$key` starts a multiline string. See below.
 
-Every value is a string. Cast the ones you need. Keys are identifiers (letters, digits, underscores),
-so attribute access like `config.deltas.l1` works with EasyDict and friends.
+Every value is a string. Cast the ones you need. A key is any run of letters, digits, `_`, `.` and `-`,
+so `file.json`, `2026-09-07` and `0` are keys. Keys that happen to be identifiers work as attributes
+(`config.deltas.l1` with EasyDict and friends); the rest are reached with brackets (`config["file.json"]`).
 
 ## Multiline strings
 
@@ -92,8 +98,8 @@ the value. Unknown tags are plain text, never an error.
 
 - **Python**: `pip install dtab` then `import dtab`
 - **JavaScript**: `npm install deltatab` then `const dtab = require('deltatab')`, or `<script src="https://cdn.jsdelivr.net/npm/deltatab/dtab.js">` for `window.dtab`
-- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, and gives the file a Δ icon in NERDTree if vim-devicons is installed.
-- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting plus a Δ file icon.
+- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, gives the file a Δ icon in NERDTree if vim-devicons is installed, and `:DtabPreview` opens a split showing the tree as JSON that follows your edits (needs `+python3`).
+- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting, a Δ file icon, and a live JSON preview of the file beside it (the preview button in the title bar, or Cmd+K V).
 
 ## API
 

{dtab-0.2.0 → dtab-0.3.0}/README.md

@@ -1,4 +1,9 @@
-<p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p>
+<!-- <p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p> -->
+<!-- <img width="6912" height="4188" alt="image" src="https://github.com/user-attachments/assets/db10af67-b7ba-4e42-a808-946c8cdcc2c7" /> -->
+<img width="6912" height="2940" alt="image" src="https://github.com/user-attachments/assets/24f2187b-9e71-45e6-9a4b-427ad00e48c8" />
+
+
+
 <p align="center"><sub>Logo made with <a href="https://github.com/RyannDaGreat/SvelteLib">PowerRP</a>. <a href="https://ryanndagreat.github.io/SvelteLib/?repo=RyannDaGreat/dtab">Open it in PowerRP</a> to edit it (source: <code>assets/doc.json</code>).</sub></p>
 
 # dtab
@@ -23,7 +28,7 @@ dtab.parse(open("scene.dtab").read())
 
 - Less to look at. No braces, quotes, or commas between values. A file with its tabs aligned reads like pseudocode, and is easy to write by hand, even on paper.
 - Simple. Six rules, one pass, about 70 lines per implementation.
-- Everything is addressable. There are no lists, so every value has a dotted path: `config.deltas.l1.position.x` works with EasyDict in Python and plain property access in JavaScript.
+- Everything is addressable. There are no lists, so every value has a path: `config.deltas.l1.position.x` with EasyDict in Python or plain property access in JavaScript, brackets for keys like `file.json`.
 - You choose the shape. Lines stack, and `c,d` writes one value under several keys, so the same tree can be written wide, deep, or on one line, trading horizontal space for vertical. These are the same file:
 
   ```
@@ -50,8 +55,9 @@ dtab.parse(open("scene.dtab").read())
 - An entry that starts with a space is a comment.
 - `$key` starts a multiline string. See below.
 
-Every value is a string. Cast the ones you need. Keys are identifiers (letters, digits, underscores),
-so attribute access like `config.deltas.l1` works with EasyDict and friends.
+Every value is a string. Cast the ones you need. A key is any run of letters, digits, `_`, `.` and `-`,
+so `file.json`, `2026-09-07` and `0` are keys. Keys that happen to be identifiers work as attributes
+(`config.deltas.l1` with EasyDict and friends); the rest are reached with brackets (`config["file.json"]`).
 
 ## Multiline strings
 
@@ -83,8 +89,8 @@ the value. Unknown tags are plain text, never an error.
 
 - **Python**: `pip install dtab` then `import dtab`
 - **JavaScript**: `npm install deltatab` then `const dtab = require('deltatab')`, or `<script src="https://cdn.jsdelivr.net/npm/deltatab/dtab.js">` for `window.dtab`
-- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, and gives the file a Δ icon in NERDTree if vim-devicons is installed.
-- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting plus a Δ file icon.
+- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, gives the file a Δ icon in NERDTree if vim-devicons is installed, and `:DtabPreview` opens a split showing the tree as JSON that follows your edits (needs `+python3`).
+- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting, a Δ file icon, and a live JSON preview of the file beside it (the preview button in the title bar, or Cmd+K V).
 
 ## API
 

{dtab-0.2.0 → dtab-0.3.0}/dtab.egg-info/PKG-INFO

@@ -1,13 +1,18 @@
 Metadata-Version: 2.4
 Name: dtab
-Version: 0.2.0
+Version: 0.3.0
 Summary: Delta Tab: config files made of tab-separated paths. One line is one path into a tree.
 Project-URL: Homepage, https://github.com/RyannDaGreat/dtab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: fire
 
-<p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p>
+<!-- <p align="center"><img src="https://raw.githubusercontent.com/RyannDaGreat/dtab/main/assets/logo.jpg" alt="dtab" width="640"></p> -->
+<!-- <img width="6912" height="4188" alt="image" src="https://github.com/user-attachments/assets/db10af67-b7ba-4e42-a808-946c8cdcc2c7" /> -->
+<img width="6912" height="2940" alt="image" src="https://github.com/user-attachments/assets/24f2187b-9e71-45e6-9a4b-427ad00e48c8" />
+
+
+
 <p align="center"><sub>Logo made with <a href="https://github.com/RyannDaGreat/SvelteLib">PowerRP</a>. <a href="https://ryanndagreat.github.io/SvelteLib/?repo=RyannDaGreat/dtab">Open it in PowerRP</a> to edit it (source: <code>assets/doc.json</code>).</sub></p>
 
 # dtab
@@ -32,7 +37,7 @@ dtab.parse(open("scene.dtab").read())
 
 - Less to look at. No braces, quotes, or commas between values. A file with its tabs aligned reads like pseudocode, and is easy to write by hand, even on paper.
 - Simple. Six rules, one pass, about 70 lines per implementation.
-- Everything is addressable. There are no lists, so every value has a dotted path: `config.deltas.l1.position.x` works with EasyDict in Python and plain property access in JavaScript.
+- Everything is addressable. There are no lists, so every value has a path: `config.deltas.l1.position.x` with EasyDict in Python or plain property access in JavaScript, brackets for keys like `file.json`.
 - You choose the shape. Lines stack, and `c,d` writes one value under several keys, so the same tree can be written wide, deep, or on one line, trading horizontal space for vertical. These are the same file:
 
   ```
@@ -59,8 +64,9 @@ dtab.parse(open("scene.dtab").read())
 - An entry that starts with a space is a comment.
 - `$key` starts a multiline string. See below.
 
-Every value is a string. Cast the ones you need. Keys are identifiers (letters, digits, underscores),
-so attribute access like `config.deltas.l1` works with EasyDict and friends.
+Every value is a string. Cast the ones you need. A key is any run of letters, digits, `_`, `.` and `-`,
+so `file.json`, `2026-09-07` and `0` are keys. Keys that happen to be identifiers work as attributes
+(`config.deltas.l1` with EasyDict and friends); the rest are reached with brackets (`config["file.json"]`).
 
 ## Multiline strings
 
@@ -92,8 +98,8 @@ the value. Unknown tags are plain text, never an error.
 
 - **Python**: `pip install dtab` then `import dtab`
 - **JavaScript**: `npm install deltatab` then `const dtab = require('deltatab')`, or `<script src="https://cdn.jsdelivr.net/npm/deltatab/dtab.js">` for `window.dtab`
-- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, and gives the file a Δ icon in NERDTree if vim-devicons is installed.
-- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting plus a Δ file icon.
+- **Vim**: `Plugin 'RyannDaGreat/dtab'` (Vundle) or `Plug 'RyannDaGreat/dtab'` (vim-plug), or paste `dtab.vim` into your vimrc. Highlights `*.dtab`, flags bad keys and trailing tabs, gives the file a Δ icon in NERDTree if vim-devicons is installed, and `:DtabPreview` opens a split showing the tree as JSON that follows your edits (needs `+python3`).
+- **VS Code**: search "dtab" in Extensions, or `code --install-extension RyannDaGreat.dtab`. Highlighting, a Δ file icon, and a live JSON preview of the file beside it (the preview button in the title bar, or Cmd+K V).
 
 ## API
 

{dtab-0.2.0 → dtab-0.3.0}/dtab.py

@@ -21,7 +21,8 @@ Rules:
   - `$key` is a multiline leaf: its value is the entries after it on its line plus every line indented
     under it, one line each, with their common indentation removed. A word after the key on the `$` line
     (`$query sql`) is a language tag for editors and is not part of the value.
-  - Keys are identifiers (str.isidentifier), so trees are EasyDict-friendly. Every value is a string.
+  - Keys are one or more letters, digits, or KEY_PUNCTUATION (`_.-`), so `file.json` and `123aa` are keys. Keys that
+    are also Python identifiers work as attributes (config.deltas.l1). Every value is a string.
 
 Single pass, one stack, O(total characters).
 """
@@ -29,12 +30,14 @@ Single pass, one stack, O(total characters).
 import json
 import re
 
-__version__ = "0.2.0"  # SEMANTIC BINDING: dtab-version (also package.json "version")
+__version__ = "0.3.0"  # SEMANTIC BINDING: dtab-version (also package.json "version")
 
 KEY_SEPARATOR = ","  # a,b writes the same value under each key
 BLOCK_PREFIX = "$"  # $key: a leaf whose value is the lines under it ($ as in string)
-KEY_RULE = "keys must be identifiers (letters, digits, underscores, not starting with a digit)"
+KEY_PUNCTUATION = "_.-"  # Allowed in keys besides letters and digits. SEMANTIC BINDING: dtab-key-punctuation
+KEY_RULE = "keys may contain only letters, digits and " + " ".join(KEY_PUNCTUATION)
 _TAB_RUN = re.compile(r"\t+")  # Several tabs in a row are one separator, so columns can be aligned
+_KEY = re.compile(r"[\w" + re.escape(KEY_PUNCTUATION) + "]+")  # \w: letters, digits, _ (Unicode); the rest is reserved for syntax
 
 
 def parse(text):
@@ -57,9 +60,11 @@ def parse(text):
         {'query': 'SELECT *\\n\\n\\tFROM users', 'next': '1'}
         >>> parse('$cmd\\tpip install rp\\tpython train.py')
         {'cmd': 'pip install rp\\npython train.py'}
-        >>> parse('a\\tb 1\\nc.d\\te 2')
+        >>> parse('a\\tb 1\\nfile.json\\tsize 2\\n123aa 3')
+        {'a': {'b': '1'}, 'file.json': {'size': '2'}, '123aa': '3'}
+        >>> parse('a\\tb 1\\nc/d\\te 2')
         Traceback (most recent call last):
-        ValueError: dtab line 2: invalid key 'c.d': keys must be identifiers (letters, digits, underscores, not starting with a digit)
+        ValueError: dtab line 2: invalid key 'c/d': keys may contain only letters, digits and _ . -
     """
     root = {}
     stack = [(-1, [root])]  # (indent, nodes that deeper lines nest into)
@@ -126,19 +131,19 @@ def stringify(tree):
 
 def _key_names(key, line_number, allow_commas):
     """
-    Pure function (raises ValueError). The identifiers a key stands for: `a,b` is two while parsing,
-    and a stringify key must be a single bare identifier.
+    Pure function (raises ValueError). The names a key stands for: `a,b` is two while parsing, and a
+    stringify key must be a single name.
 
     Examples:
-        >>> _key_names('l1,l2', 1, True), _key_names('table_bottom', None, False)
-        (['l1', 'l2'], ['table_bottom'])
+        >>> _key_names('l1,l2', 1, True), _key_names('file-thing.json', None, False)
+        (['l1', 'l2'], ['file-thing.json'])
         >>> _key_names('a,b', None, False)
         Traceback (most recent call last):
-        ValueError: dtab: invalid key 'a,b': keys must be identifiers (letters, digits, underscores, not starting with a digit)
+        ValueError: dtab: invalid key 'a,b': keys may contain only letters, digits and _ . -
     """
     names = key.split(KEY_SEPARATOR) if allow_commas else [key]
     for name in names:
-        if not name.isidentifier():
+        if not _KEY.fullmatch(name):
             where = " line %d" % line_number if line_number else ""
             raise ValueError("dtab%s: invalid key %r: %s" % (where, key, KEY_RULE))
     return names

{dtab-0.2.0 → dtab-0.3.0}/test/test_dtab.py

@@ -14,19 +14,23 @@ Checks:
      that is one leaf, deltas.initial.l1.intensity, where the original ignored the later `l1	intensity 1`),
      and `$` multiline blocks, which the original did not have.
   4. parse(stringify(parse(text))) == parse(text) for every sample.
-  5. The key rule: bad keys are rejected with a line number in parse and in stringify, and Python's
-     str.isidentifier and the JS Unicode regex agree on a set of probes.
+  5. The key rule (letters, digits, _ . -): bad keys are rejected with a line number in parse and in
+     stringify, and the Python and JS character classes agree on a set of Unicode probes.
   6. node test/test_dtab.js.
   7. Vim: the syntax groups over test/samples/highlight.dtab match test/expected/highlight.txt byte by byte
-     (that sample deliberately contains invalid keys, so it is not parsed), and plugin/dtab.vim sets the
-     filetype when the repo is on 'runtimepath', which is what Vundle and vim-plug do.
+     (that sample deliberately contains invalid keys, so it is not parsed), embedded languages, the Tab and
+     shift keys, :DtabPreview, and plugin/dtab.vim sets the filetype when the repo is on 'runtimepath',
+     which is what Vundle and vim-plug do.
   8. docs/index.html in headless Chrome (test/test_web.js), skipped with a message if puppeteer is not
      installed (`npm install --no-save puppeteer && npx puppeteer browsers install chrome`).
-  9. The VS Code extension's TextMate grammar tokenizes the vim highlight sample the same way vim does
-     (test/test_vscode.js), skipped if vscode-textmate is not installed
+  9. The VS Code extension's TextMate grammar tokenizes the vim highlight sample the same way vim does,
+     and its indentation and preview logic (test/test_vscode.js), skipped if vscode-textmate is not installed
      (`npm install --no-save vscode-textmate vscode-oniguruma`).
+ 10. The JSON preview inside the installed VS Code, in an isolated profile (test/test_vscode_live.js),
+     skipped if @vscode/test-electron is not installed.
 
-Needs: python 3, node, vim.
+Needs: python 3, node, vim. The optional packages go in together, since an `npm install --no-save` removes
+the ones it was not given: `npm install --no-save puppeteer vscode-textmate vscode-oniguruma @vscode/test-electron`.
 """
 
 import doctest
@@ -40,7 +44,7 @@ ROOT = Path(__file__).resolve().parent.parent
 HIGHLIGHT_SAMPLE = ROOT / "test" / "samples" / "highlight.dtab"
 SAMPLES = sorted(path for path in (ROOT / "test" / "samples").glob("*.dtab") if path != HIGHLIGHT_SAMPLE)
 DEVIATING = {"deviations.dtab", "game_config.dtab", "multiline.dtab"}  # multiline: $ blocks did not exist in the original
-IDENTIFIER_PROBES = ["café", "变量", "x²", "_x", "0x", "from", "items", "a-b", "ok_1", "ª", "Ⅻ", "℘", "ℕ", "𝔸", "a.b", "é1", "1é"]
+IDENTIFIER_PROBES = ["café", "变量", "x²", "_x", "0x", "a-b", "ok_1", "ª", "Ⅻ", "℘", "ℕ", "𝔸", "a.b", "é1", "1é", "a/b", "a:b", "ä-ö.ü", "١٢٣", "a~b"]   # the key rule, py vs js
 
 sys.path.insert(0, str(ROOT))
 import dtab  # noqa: E402
@@ -88,20 +92,28 @@ def test_round_trips():
 
 def test_key_rule():
     for text, fragments in [
-        ("a\tcheckpoint.initial 1", ["line 1", "'checkpoint.initial'"]),
-        ("ok 1\n\t2nd 2", ["line 2", "'2nd'"]),
-        ("a-b 1", ["'a-b'"]),
+        ("a\tc/d 1", ["line 1", "'c/d'"]),
+        ("ok 1\n\tk:v 2", ["line 2", "'k:v'"]),
         ("~scope\n\tx 1", ["'~scope'"]),
         ("log\t@ e", ["'@'"]),
-        ("a,b.c\tx 1", ["'a,b.c'"]),
+        ("a,b#c\tx 1", ["'a,b#c'"]),
+        ("\"quoted\" 1", ["'\"quoted\"'"]),
     ]:
         raises_value_error(lambda: dtab.parse(text), *fragments)
-    assert dtab.parse("items 1\nfrom 2\n_private 3\ncafé 4") == {"items": "1", "from": "2", "_private": "3", "café": "4"}
-    for tree in [{"a b": "1"}, {"a,b": "1"}, {0: "1"}, {"": "1"}]:
+    assert dtab.parse("123aa 1\nfile.json 2\nfile-thing.json 3\n123.json-yaml 4\nitems 5\n_p 6\ncafé 7\n-x 8") == {
+        "123aa": "1", "file.json": "2", "file-thing.json": "3", "123.json-yaml": "4", "items": "5", "_p": "6", "café": "7", "-x": "8"}
+    for tree in [{"a b": "1"}, {"a,b": "1"}, {"a/b": "1"}, {"": "1"}]:
         raises_value_error(lambda: dtab.stringify(tree), "dtab")
+    assert dtab.parse(dtab.stringify({0: "a", "file.json": "b"})) == {"0": "a", "file.json": "b"}   # int keys are written as text
     for value in ["x\ny", "x\ty", "a\n\n\tb\n  c", "#!/bin/bash\necho hi", ""]:
         assert dtab.parse(dtab.stringify({"a": value})) == {"a": value}, "multiline round trip failed for %r" % value
-    python_verdicts = [probe.isidentifier() for probe in IDENTIFIER_PROBES]
+    def accepted(probe):
+        try:
+            dtab.parse(probe + " 1")
+            return True
+        except ValueError:
+            return False
+    python_verdicts = [accepted(probe) for probe in IDENTIFIER_PROBES]
     js_verdicts = json.loads(run(
         "node", "-e",
         "const d = require('./dtab.js'); console.log(JSON.stringify(%s.map(p => { try { d.parse(p + ' 1'); return true } catch { return false } })))"
@@ -159,6 +171,38 @@ def test_vim_tab_key():
     assert lines[1] == "after\t 1", repr(lines[1])          # a tab outside the block
 
 
+def test_vim_shift_keys():
+    """>> and << (and visual > <) shift block lines by four spaces, other lines by a tab."""
+    with tempfile.TemporaryDirectory() as directory:
+        sample = Path(directory) / "shift.dtab"
+        sample.write_text("before 1\n$code python\n\tdef f():\n\t    return 1\n")
+        out = Path(directory) / "lines.txt"
+        vim("syntax on", "source dtab.vim", "edit " + str(sample),
+            "execute '1normal >>' | execute '1normal <<' | execute '3normal >>' | execute '4normal <<' | execute '2normal Vjj>'",
+            "call writefile(getline(1, '$'), '%s')" % out)
+        lines = out.read_text().split("\n")
+    assert lines[0] == "before 1", repr(lines[0])                 # >> gave it a tab, << took it away
+    assert lines[1] == "\t$code python", repr(lines[1])         # visual > over the $ line and its block: tabs for all
+    assert lines[2] == "\t\t    def f():", repr(lines[2])       # >> inside the block: spaces; then the block's tab
+    assert lines[3] == "\t\treturn 1", repr(lines[3])           # << inside the block removed the spaces
+
+
+def test_vim_preview():
+    """:DtabPreview opens a JSON split of the buffer's tree that follows edits (showing the parser's message when the text is broken), and closes it when repeated."""
+    sample = SAMPLES[0]
+    with tempfile.TemporaryDirectory() as directory:
+        out = Path(directory) / "preview.txt"
+        vim("syntax on", "source dtab.vim", "edit " + str(sample),
+            "DtabPreview | call writefile(getbufline(b:dtab_preview, 1, '$') + ['---'], '%s')" % out,
+            "call setline(1, 'bad/key 1') | doautocmd TextChanged",
+            "call writefile(getbufline(b:dtab_preview, 1, '$') + ['---', getbufvar(b:dtab_preview, '&filetype')], '%s', 'a')" % out,
+            "DtabPreview | call writefile([bufwinnr(b:dtab_preview)], '%s', 'a')" % out)
+        tree, message, closed = out.read_text().split("---\n")
+    assert json.loads(tree) == dtab.parse(sample.read_text()), "the preview is not the parsed tree"
+    assert message.startswith("dtab line 1: invalid key 'bad/key'"), "the preview did not follow the edit: %r" % message
+    assert closed == "json\n-1\n", "expected a json split that the second :DtabPreview closes: %r" % closed
+
+
 def test_vim_plugin_shim():
     with tempfile.TemporaryDirectory() as directory:
         out = Path(directory) / "filetype.txt"
@@ -175,15 +219,30 @@ def test_web_demo():
 
 
 def test_vscode_grammar():
+    # The committed grammar and language configuration are what vscode/make_grammar.py generates.
+    with tempfile.TemporaryDirectory() as directory:
+        sys.path.insert(0, str(ROOT / "vscode"))
+        import make_grammar  # noqa: E402
+        for written in make_grammar.write(directory):
+            committed = ROOT / "vscode" / Path(written).relative_to(directory)
+            assert Path(written).read_text() == committed.read_text(), "%s is stale: run python vscode/make_grammar.py" % committed
     if not (ROOT / "node_modules" / "vscode-textmate").is_dir():
         print("    (skipped: vscode-textmate not installed)")
         return
     subprocess.run(["node", "test/test_vscode.js"], check=True, cwd=ROOT)
 
 
+def test_vscode_live():
+    """The JSON preview inside the installed VS Code (test/test_vscode_live.js), skipped without @vscode/test-electron or the app."""
+    if not (ROOT / "node_modules" / "@vscode" / "test-electron").is_dir() or not Path("/Applications/Visual Studio Code.app").is_dir():
+        print("    (skipped: @vscode/test-electron or VS Code not installed)")
+        return
+    subprocess.run(["node", "test/test_vscode_live.js"], check=True, cwd=ROOT)
+
+
 if __name__ == "__main__":
     for test in [test_doctests, test_readers_agree, test_round_trips, test_key_rule, test_js_suite,
-                 test_vim_highlighting, test_vim_embedded_languages, test_vim_tab_key, test_vim_plugin_shim, test_web_demo, test_vscode_grammar]:
+                 test_vim_highlighting, test_vim_embedded_languages, test_vim_tab_key, test_vim_shift_keys, test_vim_preview, test_vim_plugin_shim, test_web_demo, test_vscode_grammar, test_vscode_live]:
         test()
         print("ok  " + test.__name__)
     print("All dtab tests passed")