harmonyc 0.10.4 → 0.11.0

package/README.md

@@ -64,11 +64,31 @@ Both actions and responses get compiled to simple function calls - in JavaScript
 
 ### Arguments
 
-Phrases can have arguments which are passed to the implementation function. There are two types of arguments: double-quoted strings are passed to the code as strings, and backtick-quoted strings are passed as is. You can use backticks to pass numbers, booleans, null, or objects.
+Phrases (actions and responses) can have arguments which are passed to the implementation function. There are two types of arguments: strings and code fragments:
+
+```harmony
++ strings:
+  + hello "John"
++ code fragment:
+  + greet `3` times
+```
+
+becomes
+
+```javascript
+test('T1 - strings', async () => {
+  const P = new Phrases();
+  await P.When_hello_("John");
+})
+test('T2 - code fragment', async () => {
+  const P = new Phrases();
+  await P.When_greet__times(3);
+})
+```
 
 ### Labels
 
-Label are nodes that end with `:`. You can use them to structure your test design.
+Labels are lines that start with `-` or `+` and end with `:`. You can use them to structure your test design.
 They are not included in the test case, but the test case name is generated from the labels.
 
 ### Comments
@@ -79,6 +99,35 @@ Lines starting with `#` or `//` are comments and are ignored.
 
 You can use `!!` to denote an error response. This will verify that the action throws an error. You can specify the error message after the `!!`.
 
+### Variables
+
+You can set variables in the tests and use them in strings and code fragments:
+
+```
++ set variable:
+  + ${name} "John"
+    + greet "${name}" => "hello John"
++ store result into variable:
+  + run process => ${result}
+    + "${result}" is "success"
+```
+
+becomes
+
+```javascript
+test('T1 - set variable', (context) => {
+  const P = new Phrases();
+  (context.task.meta.variables ??= {})['name'] = "John";
+  await P.When_greet_(context.task.meta.variables?.['name']);
+})
+test('T2 - store result in variable', (context) => {
+  const P = new Phrases();
+  const r = await P.When_run_process();
+  (context.task.meta.variables ??= {})['result'] = r;
+  await P.Then__is_(`${context.task.meta.variables?.['result']});
+})
+```
+
 ## Running the tests
 
 ## License

package/code_generator/{JavaScript.js → VitestGenerator.js}

@@ -1,6 +1,6 @@
 import { basename } from 'path';
 import { Arg, Word, } from "../model/model.js";
-export class NodeTest {
+export class VitestGenerator {
     constructor(tf, sf) {
         this.tf = tf;
         this.sf = sf;
@@ -59,24 +59,28 @@ export class NodeTest {
         });
         this.tf.print('});');
     }
-    errorStep(action, errorMessage) {
+    errorStep(action, errorResponse) {
         var _a;
         this.declareFeatureVariables([action]);
-        this.tf.print(`context.task.meta.phrases.push(${str(action.toString())});`);
-        this.tf.print(`context.task.meta.phrases.push(${str(errorMessage ? '!! => ' + JSON.stringify(errorMessage.text) : '!!')});`);
+        this.tf.print(`context.task.meta.phrases.push(${str(errorResponse.toSingleLineString())});`);
         this.tf.print(`await expect(async () => {`);
         this.tf.indent(() => {
             action.toCode(this);
         });
-        this.tf.print(`}).rejects.toThrow(${(_a = errorMessage === null || errorMessage === void 0 ? void 0 : errorMessage.toCode(this)) !== null && _a !== void 0 ? _a : ''});`);
+        this.tf.print(`}).rejects.toThrow(${(_a = errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.toCode(this)) !== null && _a !== void 0 ? _a : ''});`);
     }
     step(action, responses) {
         this.declareFeatureVariables([action, ...responses]);
-        this.tf.print(`context.task.meta.phrases.push(${str(action.toString())});`);
         if (responses.length === 0) {
             action.toCode(this);
             return;
         }
+        if (action.isEmpty) {
+            for (const response of responses) {
+                response.toCode(this);
+            }
+            return;
+        }
         const res = `r${this.resultCount++ || ''}`;
         this.tf.print(`const ${res} =`);
         this.tf.indent(() => {
@@ -84,7 +88,6 @@ export class NodeTest {
             try {
                 this.extraArgs = [res];
                 for (const response of responses) {
-                    this.tf.print(`context.task.meta.phrases.push(${str(`=> ${response.toString()}`)});`);
                     response.toCode(this);
                 }
             }
@@ -110,13 +113,25 @@ export class NodeTest {
         const f = this.featureVars.get(p.feature.name);
         const args = p.args.map((a) => a.toCode(this));
         args.push(...this.extraArgs);
-        this.tf.print(`await ${f}.${functionName(p)}(${args.join(', ')});`);
+        this.tf.print(`(context.task.meta.phrases.push(${str(p.toString())}),`);
+        this.tf.print(`await ${f}.${functionName(p)}(${args.join(', ')}));`);
+    }
+    setVariable(action) {
+        this.tf.print(`(context.task.meta.variables ??= {})[${str(action.variableName)}] = ${action.value.toCode(this)};`);
     }
-    stringLiteral(text) {
+    saveToVariable(s) {
+        if (this.extraArgs.length !== 1)
+            return;
+        this.tf.print(`(context.task.meta.variables ??= {})[${str(s.variableName)}] = ${this.extraArgs[0]};`);
+    }
+    stringLiteral(text, { withVariables }) {
+        if (withVariables && text.match(/\$\{/)) {
+            return templateStr(text).replace(/\\\$\{([^\s}]+)\}/g, (_, x) => `\${context.task.meta.variables?.[${str(x)}]}`);
+        }
         return str(text);
     }
     codeLiteral(src) {
-        return src;
+        return src.replace(/\$\{([^\s}]+)\}/g, (_, x) => `context.task.meta.variables?.[${str(x)}]`);
     }
     paramName(index) {
         return 'xyz'.charAt(index) || `a${index + 1}`;
@@ -171,7 +186,7 @@ function abbrev(s) {
 export function functionName(phrase) {
     const { kind } = phrase;
     return ((kind === 'response' ? 'Then_' : 'When_') +
-        ([...phrase.content, phrase.docstring ? [phrase.docstring] : []]
+        (phrase.parts
             .flatMap((c) => c instanceof Word
             ? words(c.text).filter((x) => x)
             : c instanceof Arg

package/code_generator/outFile.js

@@ -42,7 +42,9 @@ export class OutFile {
     get value() {
         let res = this.lines.join('\n');
         if (this.currentLoc) {
-            res += `\n\n//# sourceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`;
+            res +=
+                `\n\n//# sour` + // not for this file ;)
+                    `ceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`;
         }
         return res;
     }

package/compiler/compile.js

@@ -1,4 +1,4 @@
-import { NodeTest } from "../code_generator/JavaScript.js";
+import { VitestGenerator } from "../code_generator/VitestGenerator.js";
 import { OutFile } from "../code_generator/outFile.js";
 import { parse } from "../parser/parser.js";
 import { base, phrasesFileName, testFileName } from "../filenames/filenames.js";
@@ -26,7 +26,7 @@ export function compileFeature(fileName, src) {
     const testFile = new OutFile(testFn);
     const phrasesFn = phrasesFileName(fileName);
     const phrasesFile = new OutFile(phrasesFn);
-    const cg = new NodeTest(testFile, phrasesFile);
+    const cg = new VitestGenerator(testFile, phrasesFile);
     feature.toCode(cg);
     return { outFile: testFile, phrasesFile };
 }

package/model/model.js

@@ -94,7 +94,7 @@ export class Step extends Branch {
     }
     toCode(cg) {
         if (this.responses[0] instanceof ErrorResponse) {
-            cg.errorStep(this.action, this.responses[0].message);
+            cg.errorStep(this.action, this.responses[0]);
         }
         else {
             cg.step(this.action, this.responses);
@@ -107,7 +107,7 @@ export class Step extends Branch {
         return super.setFeature(feature);
     }
     headToString() {
-        return `${this.action}` + this.responses.map((r) => ` => ${r}`).join('');
+        return this.phrases.join(' ');
     }
     toString() {
         return this.headToString() + indent(super.toString());
@@ -145,6 +145,18 @@ export class Section extends Branch {
     }
 }
 export class Part {
+    toSingleLineString() {
+        return this.toString();
+    }
+}
+export class DummyKeyword extends Part {
+    constructor(text = '') {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
 }
 export class Word extends Part {
     constructor(text = '') {
@@ -165,13 +177,30 @@ export class StringLiteral extends Arg {
     toString() {
         return JSON.stringify(this.text);
     }
+    toSingleLineString() {
+        return this.toString();
+    }
     toCode(cg) {
-        return cg.stringLiteral(this.text);
+        return cg.stringLiteral(this.text, { withVariables: true });
     }
     toDeclaration(cg, index) {
         return cg.stringParamDeclaration(index);
     }
 }
+export class Docstring extends StringLiteral {
+    toCode(cg) {
+        return cg.stringLiteral(this.text, { withVariables: false });
+    }
+    toString() {
+        return this.text
+            .split('\n')
+            .map((l) => '| ' + l)
+            .join('\n');
+    }
+    toSingleLineString() {
+        return super.toString();
+    }
+}
 export class CodeLiteral extends Arg {
     constructor(src = '') {
         super();
@@ -188,37 +217,31 @@ export class CodeLiteral extends Arg {
     }
 }
 export class Phrase {
-    constructor(content = [], docstring) {
-        this.content = content;
-        this.docstring =
-            docstring === undefined ? undefined : new StringLiteral(docstring);
+    constructor(parts) {
+        this.parts = parts;
     }
     setFeature(feature) {
         this.feature = feature;
+        return this;
     }
     get keyword() {
         return this.kind === 'action' ? 'When' : 'Then';
     }
     get args() {
-        return [...this.content, this.docstring].filter((c) => c instanceof Arg);
+        return this.parts.filter((c) => c instanceof Arg);
     }
     get isEmpty() {
-        return this.content.length === 0 && this.docstring === undefined;
+        return this.parts.length === 0;
     }
     toString() {
-        return [
-            ...(this.content.length > 0
-                ? [this.content.map((c) => c.toString()).join(' ')]
-                : []),
-            ...(this.docstring !== undefined
-                ? this.docstring.text.split('\n').map((l) => '| ' + l)
-                : []),
-        ].join('\n');
+        const parts = this.parts.map((p) => p.toString());
+        const isMultiline = parts.map((p) => p.includes('\n'));
+        return parts
+            .map((p, i) => i === 0 ? p : isMultiline[i - 1] || isMultiline[i] ? '\n' + p : ' ' + p)
+            .join('');
     }
     toSingleLineString() {
-        return [...this.content, ...(this.docstring ? [this.docstring] : [])]
-            .map((c) => c.toString())
-            .join(' ');
+        return this.parts.map((p) => p.toSingleLineString()).join(' ');
     }
 }
 export class Action extends Phrase {
@@ -227,7 +250,7 @@ export class Action extends Phrase {
         this.kind = 'action';
     }
     toCode(cg) {
-        if (!this.content.length && this.docstring === undefined)
+        if (this.isEmpty)
             return;
         cg.phrase(this);
     }
@@ -237,27 +260,41 @@ export class Response extends Phrase {
         super(...arguments);
         this.kind = 'response';
     }
-    get isErrorResponse() {
-        if (this.content.length === 1 &&
-            this.content[0] instanceof Word &&
-            this.content[0].text === '!!')
-            return true;
-        if (this.content.length === 2 &&
-            this.content[0] instanceof Word &&
-            this.content[0].text === '!!' &&
-            this.content[1] instanceof StringLiteral)
-            return true;
+    toString() {
+        return `=> ${super.toString()}`;
+    }
+    toSingleLineString() {
+        return `=> ${super.toSingleLineString()}`;
     }
     toCode(cg) {
-        if (!this.content.length && this.docstring === undefined)
+        if (this.isEmpty)
             return;
         cg.phrase(this);
     }
 }
 export class ErrorResponse extends Response {
-    get message() {
-        var _a;
-        return (_a = this.content[0]) !== null && _a !== void 0 ? _a : this.docstring;
+    constructor(message) {
+        super(message ? [new DummyKeyword('!!'), message] : [new DummyKeyword('!!')]);
+        this.message = message;
+    }
+}
+export class SetVariable extends Action {
+    constructor(variableName, value) {
+        super([new DummyKeyword(`\${${variableName}}`), value]);
+        this.variableName = variableName;
+        this.value = value;
+    }
+    toCode(cg) {
+        cg.setVariable(this);
+    }
+}
+export class SaveToVariable extends Response {
+    constructor(variableName) {
+        super([new DummyKeyword(`\${${variableName}}`)]);
+        this.variableName = variableName;
+    }
+    toCode(cg) {
+        cg.saveToVariable(this);
     }
 }
 export class Precondition extends Branch {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {

package/parser/lexer.js

@@ -1,4 +1,123 @@
-import { buildLexer } from 'typescript-parsec';
+import { TokenError } from 'typescript-parsec';
 import rules from './lexer_rules.js';
 export { T } from './lexer_rules.js';
-export const lexer = buildLexer(rules);
+// based on https://github.com/microsoft/ts-parsec/blob/3350fcb/packages/ts-parsec/src/Lexer.ts
+/*
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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
+*/
+class TokenImpl {
+    constructor(lexer, input, kind, text, pos, keep) {
+        this.lexer = lexer;
+        this.input = input;
+        this.kind = kind;
+        this.text = text;
+        this.pos = pos;
+        this.keep = keep;
+    }
+    get next() {
+        if (this.nextToken === undefined) {
+            this.nextToken = this.lexer.parseNextAvailable(this.input, this.pos.index + this.text.length, this.pos.rowEnd, this.pos.columnEnd);
+            if (this.nextToken === undefined) {
+                this.nextToken = null;
+            }
+        }
+        return this.nextToken === null ? undefined : this.nextToken;
+    }
+}
+class LexerImpl {
+    constructor(rules) {
+        this.rules = rules;
+        for (const rule of this.rules) {
+            if (!rule[1].sticky) {
+                throw new Error(`Regular expression patterns for a tokenizer should be sticky: ${rule[1].source}`);
+            }
+        }
+    }
+    parse(input) {
+        return this.parseNextAvailable(input, 0, 1, 1);
+    }
+    parseNext(input, indexStart, rowBegin, columnBegin) {
+        if (indexStart === input.length) {
+            return undefined;
+        }
+        // changed here: instead of slicing the input string, we use a running index
+        const lastIndex = indexStart;
+        // let result: TokenImpl<T> | undefined
+        for (const [keep, regexp, kind] of this.rules) {
+            // changed here: instead of slicing the input string, we use a running index
+            regexp.lastIndex = lastIndex;
+            if (regexp.test(input)) {
+                // changed here: instead of slicing the input string, we use a running index
+                const text = input.slice(lastIndex, regexp.lastIndex);
+                let rowEnd = rowBegin;
+                let columnEnd = columnBegin;
+                for (const c of text) {
+                    switch (c) {
+                        case '\r':
+                            break;
+                        case '\n':
+                            rowEnd++;
+                            columnEnd = 1;
+                            break;
+                        default:
+                            columnEnd++;
+                    }
+                }
+                const newResult = new TokenImpl(this, input, kind, text, { index: indexStart, rowBegin, columnBegin, rowEnd, columnEnd }, keep);
+                // changed here: instead of keeping the longest token, we keep the first one
+                return newResult;
+                // if (
+                //   result === undefined ||
+                //   result.text.length < newResult.text.length
+                // ) {
+                //   result = newResult
+                // }
+            }
+        }
+        // changed here: instead of keeping the longest token, we keep the first one
+        // if (result === undefined) {
+        throw new TokenError({
+            index: indexStart,
+            rowBegin,
+            columnBegin,
+            rowEnd: rowBegin,
+            columnEnd: columnBegin,
+        }, `Unable to tokenize the rest of the input: ${input.substr(indexStart)}`);
+        // } else {
+        //   return result
+        // }
+    }
+    parseNextAvailable(input, index, rowBegin, columnBegin) {
+        let token;
+        while (true) {
+            token = this.parseNext(input, token === undefined ? index : token.pos.index + token.text.length, token === undefined ? rowBegin : token.pos.rowEnd, token === undefined ? columnBegin : token.pos.columnEnd);
+            if (token === undefined) {
+                return undefined;
+            }
+            else if (token.keep) {
+                return token;
+            }
+        }
+    }
+}
+export const lexer = new LexerImpl(rules);

package/parser/lexer_rules.js

@@ -21,42 +21,44 @@ export var T;
     T["InvalidTab"] = "invalid tab";
     T["MultilineString"] = "multiline string";
     T["InvalidMultilineStringMark"] = "invalid multiline string mark";
+    T["Variable"] = "variable";
+    T["InvalidEmptyVariable"] = "invalid empty variable";
+    T["UnclosedVariable"] = "unclosed variable";
 })(T || (T = {}));
 const rules = [
     // false = ignore token
-    // if multiple patterns match, the longest one wins, if same, the former
-    // patterns must start with ^ and be /g
-    [true, /^\n/g, T.Newline],
-    [true, /^\t/g, T.InvalidTab],
-    [true, /^[\x00-\x1f]/g, T.InvalidWhitespace],
-    [true, /^ /g, T.Space],
-    [false, /^(#|>|\/\/).*?(?=\n|$)/g, T.Comment],
-    [true, /^:(?=\s*(?:\n|$))/g, T.Colon],
+    // if multiple patterns match, the former wins
+    // patterns must be y (sticky)
+    [true, /\n/y, T.Newline],
+    [true, /\t/y, T.InvalidTab],
+    [true, /[\x00-\x1f]/y, T.InvalidWhitespace],
+    [true, /^(  )*[+]( |$)/my, T.Plus],
+    [true, /^(  )*[-]( |$)/my, T.Minus],
+    [false, / /y, T.Space],
+    [false, /(#|\/\/).*?(?=\n|$)/y, T.Comment],
+    [true, /:(?=\s*(?:\n|$))/y, T.Colon],
+    [true, /\[/y, T.OpeningBracket],
+    [true, /\]/y, T.ClosingBracket],
+    [true, /!!/y, T.ErrorMark],
+    [true, /=>/y, T.ResponseArrow],
     [
         true,
-        /^(?!\s|=>|!!|- |\+ |[\[\]"`|]|:\s*(?:\n|$)).+?(?=[\[\]"`|]|\n|$|=>|!!|:\s*(?:\n|$)|$)/g,
-        T.Words,
-    ],
-    [true, /^-/g, T.Minus],
-    [true, /^\+/g, T.Plus],
-    [true, /^\[/g, T.OpeningBracket],
-    [true, /^\]/g, T.ClosingBracket],
-    [true, /^!!/g, T.ErrorMark],
-    [true, /^=>/g, T.ResponseArrow],
-    [
-        true,
-        /^"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/g,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/y,
         T.DoubleQuoteString,
     ],
     [
         true,
-        /^"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*/g,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*/y,
         T.UnclosedDoubleQuoteString,
     ],
-    [true, /^``/g, T.InvalidEmptyBacktickString],
-    [true, /^`[^`]+`/g, T.BacktickString],
-    [true, /^`[^`]*/g, T.UnclosedBacktickString],
-    [true, /^\|(?: .*|(?=\n|$))/g, T.MultilineString],
-    [true, /^\|[^ \n]/g, T.InvalidMultilineStringMark],
+    [true, /``/y, T.InvalidEmptyBacktickString],
+    [true, /`[^`]+`/y, T.BacktickString],
+    [true, /`[^`]*/y, T.UnclosedBacktickString],
+    [true, /\$\{[^}\n]+\}/y, T.Variable],
+    [true, /\$\{\}/y, T.InvalidEmptyVariable],
+    [true, /\$\{[^}\n]*/y, T.UnclosedVariable],
+    [true, /\|(?: .*|(?=\n|$))/y, T.MultilineString],
+    [true, /\|[^ \n]/y, T.InvalidMultilineStringMark],
+    [true, /.+?(?=[\[\]"`|#]|\/\/|\$\{|$|=>|!!|:\s*$)/my, T.Words],
 ];
 export default rules;

package/parser/parser.js

@@ -1,49 +1,25 @@
-import { alt_sc, apply, expectEOF, expectSingleResult, kright, opt_sc, rep_sc, seq, tok, list_sc, kleft, kmid, fail, } from 'typescript-parsec';
+import { alt_sc, apply, expectEOF, expectSingleResult, kright, opt_sc, rep_sc, seq, tok, list_sc, kleft, kmid, fail, nil, alt, } from 'typescript-parsec';
 import { T, lexer } from "./lexer.js";
-import { Action, Response, CodeLiteral, StringLiteral, Section, Step, Word, Label, ErrorResponse, } from "../model/model.js";
+import { Action, Response, CodeLiteral, StringLiteral, Section, Step, Docstring, Word, Label, ErrorResponse, SaveToVariable, SetVariable, } from "../model/model.js";
 export function parse(input, production = TEST_DESIGN) {
     const tokens = lexer.parse(input);
     return expectSingleResult(expectEOF(production.parse(tokens)));
 }
-export const S = rep_sc(tok(T.Space));
-export const NEWLINES = list_sc(tok(T.Newline), S); // empty lines can have spaces
-export const WORDS = apply(tok(T.Words), ({ text }) => new Word(text.trimEnd().split(/\s+/).join(' ')));
-export const ERROR_MARK = apply(tok(T.ErrorMark), ({ text }) => new Word(text));
-export const BULLET_POINT_LIKE_WORD = apply(alt_sc(tok(T.Plus), tok(T.Minus)), ({ text }) => new Word(text));
-export const DOUBLE_QUOTE_STRING = alt_sc(apply(tok(T.DoubleQuoteString), ({ text }) => new StringLiteral(JSON.parse(text))), seq(tok(T.UnclosedDoubleQuoteString), fail('unclosed double-quote string')));
-export const BACKTICK_STRING = apply(tok(T.BacktickString), ({ text }) => new CodeLiteral(text.slice(1, -1)));
-export const DOCSTRING = apply(list_sc(tok(T.MultilineString), seq(tok(T.Newline), S)), (lines) => lines.map(({ text }) => text.slice(2)).join('\n'));
-export const PART = alt_sc(WORDS, ERROR_MARK, BULLET_POINT_LIKE_WORD, DOUBLE_QUOTE_STRING, BACKTICK_STRING);
-export const PHRASE = seq(opt_sc(list_sc(PART, S)), opt_sc(kright(opt_sc(NEWLINES), kright(S, DOCSTRING))));
-export const ACTION = apply(PHRASE, ([parts, docstring]) => new Action(parts, docstring));
-export const RESPONSE = apply(PHRASE, ([parts, docstring]) => {
-    if ((parts === null || parts === void 0 ? void 0 : parts[0]) instanceof Word && parts[0].text === '!!') {
-        return new ErrorResponse(parts.slice(1), docstring);
-    }
-    return new Response(parts, docstring);
-});
-export const ARROW = kmid(seq(opt_sc(NEWLINES), S), tok(T.ResponseArrow), S);
-export const RESPONSE_ITEM = kright(ARROW, RESPONSE);
-export const STEP = apply(seq(ACTION, rep_sc(RESPONSE_ITEM)), ([action, responses]) => new Step(action, responses).setFork(true));
-export const LABEL = apply(kleft(list_sc(PART, S), seq(tok(T.Colon), S)), (words) => new Label(words.map((w) => w.toString()).join(' ')));
-export const SECTION = apply(LABEL, (text) => new Section(text));
-export const BRANCH = alt_sc(SECTION, STEP); // section first, to make sure there is no colon after step
-export const DENTS = apply(opt_sc(seq(S, alt_sc(tok(T.Plus), tok(T.Minus)), tok(T.Space))), (lineHead) => {
-    if (!lineHead)
-        return { dent: 0, isFork: true };
-    const [dents, seqOrFork] = lineHead;
-    return { dent: dents.length / 2, isFork: seqOrFork.kind === T.Plus };
-});
-export const LINE = apply(seq(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
+export const NEWLINES = list_sc(tok(T.Newline), nil()), WORDS = apply(tok(T.Words), ({ text }) => new Word(text.trimEnd().split(/\s+/).join(' '))), DOUBLE_QUOTE_STRING = alt_sc(apply(tok(T.DoubleQuoteString), ({ text }) => new StringLiteral(JSON.parse(text))), seq(tok(T.UnclosedDoubleQuoteString), fail('unclosed double-quote string'))), BACKTICK_STRING = apply(tok(T.BacktickString), ({ text }) => new CodeLiteral(text.slice(1, -1))), DOCSTRING = kright(opt_sc(NEWLINES), apply(list_sc(tok(T.MultilineString), tok(T.Newline)), (lines) => new Docstring(lines.map(({ text }) => text.slice(2)).join('\n')))), ERROR_MARK = tok(T.ErrorMark), VARIABLE = apply(tok(T.Variable), ({ text }) => text.slice(2, -1)), PART = alt_sc(WORDS, DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), PHRASE = rep_sc(PART), ARG = alt_sc(DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), SET_VARIABLE = apply(seq(VARIABLE, ARG), ([variable, value]) => new SetVariable(variable, value)), ACTION = alt(apply(PHRASE, (parts) => new Action(parts)), SET_VARIABLE), RESPONSE = apply(PHRASE, (parts) => new Response(parts)), ERROR_RESPONSE = apply(seq(ERROR_MARK, opt_sc(alt_sc(DOUBLE_QUOTE_STRING, DOCSTRING))), ([, parts]) => new ErrorResponse(parts)), SAVE_TO_VARIABLE = apply(VARIABLE, (variable) => new SaveToVariable(variable)), ARROW = kright(opt_sc(NEWLINES), tok(T.ResponseArrow)), RESPONSE_ITEM = kright(ARROW, alt(RESPONSE, ERROR_RESPONSE, SAVE_TO_VARIABLE)), STEP = apply(seq(ACTION, rep_sc(RESPONSE_ITEM)), ([action, responses]) => new Step(action, responses).setFork(true)), LABEL = apply(kleft(list_sc(PART, nil()), tok(T.Colon)), (words) => new Label(words.map((w) => w.toString()).join(' '))), SECTION = apply(LABEL, (text) => new Section(text)), BRANCH = alt_sc(SECTION, STEP), // section first, to make sure there is no colon after step
+DENTS = apply(alt_sc(tok(T.Plus), tok(T.Minus)), (seqOrFork) => {
+    return {
+        dent: (seqOrFork.text.length - 2) / 2,
+        isFork: seqOrFork.kind === T.Plus,
+    };
+}), LINE = apply(seq(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
     dent,
     branch: branch.setFork(isFork),
-}));
-export const TEST_DESIGN = kmid(rep_sc(NEWLINES), apply(list_sc(apply(LINE, (line, [start, end]) => ({ line, start, end })), NEWLINES), (lines) => {
+})), TEST_DESIGN = kmid(rep_sc(NEWLINES), apply(opt_sc(list_sc(apply(LINE, (line, [start, end]) => ({ line, start, end })), NEWLINES)), (lines) => {
     const startDent = 0;
     let dent = startDent;
     const root = new Section(new Label(''));
     let parent = root;
-    for (const { line, start } of lines) {
+    for (const { line, start } of lines !== null && lines !== void 0 ? lines : []) {
         const { dent: d, branch } = line;
         if (Math.round(d) !== d) {
             throw new Error(`invalid odd indent of ${d * 2} at line ${start.pos.rowBegin}`);
@@ -66,13 +42,4 @@ export const TEST_DESIGN = kmid(rep_sc(NEWLINES), apply(list_sc(apply(LINE, (lin
         parent.addChild(branch);
     }
     return root;
-}), seq(rep_sc(NEWLINES), S));
-function inputText(start, end) {
-    let text = '';
-    let t = start;
-    while (t && t !== end) {
-        text += t.text;
-        t = t.next;
-    }
-    return text;
-}
+}), rep_sc(NEWLINES));