reladraw 0.15.1 → 0.16.0

package/README.md

@@ -82,7 +82,7 @@ That gets you a copy of the skill at the time you run it, so you'll need to re-r
 
 ## Status
 
-Version 0.15.1. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
+Version 0.16.0. Early stage, but works. The parser, layout engine, and SVG renderer are written in TypeScript, with zero runtime dependencies. There is a command-line tool that turns a .reladraw text file into an SVG, and an element that does the same inside a web page.
 
 The language isn't stable yet, so expect the syntax to change.
 

package/SYNTAX.md

@@ -1,4 +1,4 @@
-# Syntax reference — 0.15.1
+# Syntax reference — 0.16.0
 
 What the language accepts. The parser, resolver and SVG renderer implement all of it; the sections at the end record what is defective, unchecked or undecided.
 
@@ -14,7 +14,7 @@ node desktop1 "Desktop 1 / Linux"
   badge: desktop  style: synced
 ```
 
-A line that starts with whitespace continues the statement above it, and a blank line or the next unindented line ends it. How much whitespace makes no difference — one space and a tab mean the same — so nothing can depend on indentation you cannot see. A bracket may stay open across lines, as in `line: (color: red,` with `pattern: dashed)` on the next. There are no blocks: indentation continues a statement, and never puts one thing inside another.
+A line that starts with whitespace continues the statement above it, and a blank line or the next unindented line ends it. How much whitespace makes no difference — one space and a tab mean the same — so nothing can depend on indentation you cannot see. None after a key's colon is an amount too: `gap:tight` is `gap: tight`. A bracket may stay open across lines, as in `line: (color: red,` with `pattern: dashed)` on the next. There are no blocks: indentation continues a statement, and never puts one thing inside another.
 
 An indented line with no statement to continue — at the top of the file, or after a blank line or an unindented comment — is an error rather than a statement of its own, and so is an indented line starting with a statement keyword such as `node`. Both are almost always a stray indent, and both say to remove it.
 
@@ -43,7 +43,7 @@ Attribute values are a single bare word unless quoted. No commas between attribu
 node <name> ["<text>" [(<text properties>)]] [<placement> | <attribute>] ...
 ```
 
-`name` identifies the node and must be unique. `text` is what appears inside it, with ` / ` — a slash with whitespace on both sides — marking a line break.
+`name` identifies the node and must be unique. It may not contain `:`, which would make it a key, or `;`, which is reserved. `text` is what appears inside it, with ` / ` — a slash with whitespace on both sides — marking a line break.
 
 The text is optional, and a node without it takes its own name as its text:
 
@@ -1140,6 +1140,14 @@ That one was found by testing the lexer, not by rendering — and it could not h
 
 Pre-1.0, so the minor number is where a breaking change goes. Every removal below is refused by name with the replacement quoted, rather than dropped in silence — an older file stops with an error saying what to write instead.
 
+**0.16.0**
+
+A name containing `:` or `;` is now refused; nothing else that worked is. No example diagram draws differently.
+
+- A key may be written against its value: `gap:tight` is `gap: tight`, and `(gap:wide)` and `line:(color:red)` work too. The amount of whitespace never mattered, and now none counts as an amount.
+- Breaking: a name may no longer contain `:` or `;`. A colon now makes the word before it a key, and a semicolon is reserved. `node a:b` used to declare a node called `a:b`, and is now refused with an error saying why.
+- `right of a, gap: tight` names the comma as the mistake. A comma after a target promises another, and the error used to blame `tight`, two words further on.
+
 **0.15.1**
 
 No syntax changes, and no file that worked is refused. No example diagram draws differently.

package/dist/lexer.d.ts

@@ -5,6 +5,12 @@ export interface Token {
     quoted: boolean;
     /** True when the string was written between `"""` marks. */
     triple?: boolean;
+    /**
+     * The whole word as written, on a key split from its value: `gap:tight` lexes
+     * as `gap:` and `tight`, and this is `gap:tight` on the first. Kept so an error
+     * about the word can quote what the author typed.
+     */
+    joined?: string;
 }
 /**
  * A `"""` string still open at the end of the text given. `parse` catches this
@@ -37,5 +43,11 @@ export declare class OpenString extends SourceError {
  * Returns an empty array for a blank or comment-only line.
  */
 export declare function tokenizeLine(line: string, lineNumber: number, depth?: number): Token[];
+/**
+ * The character in a word that a name may not hold, if any. A colon makes the
+ * word a key, written with or without its space, and `;` is kept free so it
+ * could one day separate clauses without changing what any file means.
+ */
+export declare function nameMark(token: Token): ':' | ';' | undefined;
 /** A bare token ending in `:` opens the attribute section of a statement. */
 export declare function isAttrKey(token: Token): boolean;

package/dist/lexer.js

@@ -1,4 +1,10 @@
 import { SourceError } from './errors.js';
+/**
+ * A key written against its value. The key part is spelled as the highlighter's
+ * attribute pattern spells one, and a value opening with a slash is left whole,
+ * so a file name such as `C:/icons/disk.svg` is not torn at the drive letter.
+ */
+const JOINED_KEY = /^([A-Za-z][A-Za-z0-9_-]*:)([^/\\].*)$/;
 /**
  * A `"""` string still open at the end of the text given. `parse` catches this
  * one, adds the next line and tries again, which is how a string runs over
@@ -93,6 +99,7 @@ export function tokenizeLine(line, lineNumber, depth = 0) {
             tokens.push({ text, quoted: true });
             continue;
         }
+        const start = i;
         let text = '';
         while (i < line.length) {
             const c = line[i];
@@ -105,10 +112,37 @@ export function tokenizeLine(line, lineNumber, depth = 0) {
             text += c;
             i += 1;
         }
+        // `gap:tight` is `gap: tight` with no space, since how much whitespace there
+        // is never matters. A word straight after a key is its value and is left
+        // whole, so `icon: a:b` still names an icon called `a:b`. The rest of the
+        // word is read again from just past the colon rather than kept as one
+        // token, so `line:(color:red)` opens its bracket as `line: (color: red)` does.
+        const previous = tokens[tokens.length - 1];
+        const joined = previous && isAttrKey(previous) ? null : JOINED_KEY.exec(text);
+        if (joined) {
+            tokens.push({ text: joined[1], quoted: false, joined: text });
+            i = start + joined[1].length;
+            continue;
+        }
         tokens.push({ text, quoted: false });
     }
     return tokens;
 }
+/**
+ * The character in a word that a name may not hold, if any. A colon makes the
+ * word a key, written with or without its space, and `;` is kept free so it
+ * could one day separate clauses without changing what any file means.
+ */
+export function nameMark(token) {
+    const written = token.joined ?? token.text;
+    if (token.quoted)
+        return undefined;
+    if (written.includes(':'))
+        return ':';
+    if (written.includes(';'))
+        return ';';
+    return undefined;
+}
 /** A bare token ending in `:` opens the attribute section of a statement. */
 export function isAttrKey(token) {
     return !token.quoted && token.text.length > 1 && token.text.endsWith(':');

package/dist/parser.js

@@ -1,7 +1,7 @@
 import { COLOR_KEYS, DEFAULT_KEYS, DEFAULT_TARGETS, DIAGRAM_KEYS, DIRECTIONS, describePlacement, SIDE_AXIS, SIDES, PASSAGE_AXES, TEXT_KEYS, LINE_KEYS, LINE_VALUES, CONTENTS_KEYS, PLACEMENT_KEYS, BOUNDARY_PARTS, INWARD, MARKS, MARK_GLYPHS, OPPOSITE, isDirection, isPart, isPosition, listTargets, nameTarget, } from './ast.js';
 import { SourceError } from './errors.js';
 import { STATEMENT_KEYWORDS } from './grammar.js';
-import { isAttrKey, OpenString, tokenizeLine } from './lexer.js';
+import { isAttrKey, nameMark, OpenString, tokenizeLine } from './lexer.js';
 import { THEME_COLORS, THEME_NAMES, THEMES } from './themes.js';
 /**
  * Parse a whole source file. A statement starts on an unindented line and runs
@@ -645,6 +645,7 @@ function parseEdge(head, line) {
     if (!rightToken || rightToken.quoted) {
         throw new SourceError('an edge needs a node on the right of the arrow', line);
     }
+    refuseNameMark(rightToken, `edge ${left} ${arrow.text} ${rightToken.joined ?? rightToken.text}`, line);
     let at = arrow.next + 1;
     const stray = head[at];
     if (stray &&
@@ -857,8 +858,23 @@ function requireName(token, keyword, line) {
     if (!token || token.quoted) {
         throw new SourceError(`${keyword} needs a name`, line);
     }
+    refuseNameMark(token, `${keyword} "${token.joined ?? token.text}"`, line);
     return token.text;
 }
+/**
+ * A word with a colon or a semicolon in it, where a name belongs. Both used to
+ * be ordinary characters in a name, so this refuses files that once parsed, and
+ * says why rather than reporting whatever the split word turned into next.
+ */
+function refuseNameMark(token, where, line) {
+    const mark = nameMark(token);
+    if (mark === undefined)
+        return;
+    const reason = mark === ':'
+        ? 'a colon makes the word before it a key, with or without a space after it'
+        : 'a semicolon is reserved';
+    throw new SourceError(`${where}: a name may not contain "${mark}", because ${reason}`, line);
+}
 /**
  * Read one placement. A direction and a target (`right of docker`, `below
  * deploy`), an alignment (`level with docker`), or an overlay (`on hub at
@@ -920,6 +936,11 @@ function readPlacement(tokens, at, line, subject) {
                 `${word.text}\` to straddle it, or a direction like ${DIRECTIONS.join(', ')} to put ` +
                 'it outside', line);
         }
+        // A semicolon is reserved rather than ordinary, and someone writing one
+        // between clauses wants to know that spaces already do that job.
+        if (word.text.startsWith(';')) {
+            throw new SourceError(`${subject}: ";" separates nothing — clauses are separated by spaces alone`, line);
+        }
         throw new SourceError(`${subject}: "${word.text}" is not a direction`, line);
     }
     let next = at + 1;
@@ -1130,11 +1151,23 @@ function isSideWord(word) {
 function readTargets(tokens, start, subject, placement, line, partFirst = false) {
     const targets = [];
     let i = start;
+    /** The target just closed with a comma, which promises another. */
+    let comma;
     for (;;) {
         const token = tokens[i];
-        if (!token || token.quoted || token.text === '(' || token.text === ')') {
+        // `right of a, gap: tight`: the comma, not the key, is the mistake, and
+        // reading on would take `gap:` as a name and blame the word after it.
+        if (comma !== undefined && (!token || isAttrKey(token) || token.text === '(' || token.text === ')')) {
+            const next = token ? `, but "${token.joined ?? token.text}" ${isAttrKey(token) ? 'is a key' : 'is not a name'}` : '';
+            throw new SourceError(`${subject}: the comma after "${comma}" starts another target${next} — remove the comma`, line);
+        }
+        // A key written with its space, as in `right of gap: tight`, is a target
+        // left out. One written without, `right of a:b`, is more likely a name with
+        // a colon in it, and that gets its own message below.
+        if (!token || token.quoted || token.text === '(' || token.text === ')' || (isAttrKey(token) && !token.joined)) {
             throw new SourceError(`${subject}: "${placement}" names no node`, line);
         }
+        refuseNameMark(token, `${subject}: "${token.joined ?? token.text}"`, line);
         const listed = token.text.endsWith(',') && token.text.length > 1;
         const name = listed ? token.text.slice(0, -1) : token.text;
         i += 1;
@@ -1148,6 +1181,7 @@ function readTargets(tokens, start, subject, placement, line, partFirst = false)
             i += 1;
             continue;
         }
+        comma = listed ? name : undefined;
         if (listed)
             continue;
         return { targets, next: i };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reladraw",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "A diagram language where you say where things go.",
   "type": "module",
   "bin": {