harmonyc 0.6.0-8 → 0.7.0

package/model/model.js

@@ -0,0 +1,364 @@
+import { Routers } from "./Router.js";
+export class Feature {
+    constructor(name) {
+        this.name = name;
+        this.root = new Section();
+        this.prelude = '';
+    }
+    get tests() {
+        return makeTests(this.root);
+    }
+    get testGroups() {
+        return makeGroups(this.tests);
+    }
+    toCode(cg) {
+        cg.feature(this);
+    }
+}
+export class Branch {
+    constructor(children = []) {
+        this.isFork = false;
+        this.isEnd = false;
+        this.children = children;
+        children.forEach((child) => (child.parent = this));
+    }
+    setFork(isFork) {
+        this.isFork = isFork;
+        return this;
+    }
+    setFeature(feature) {
+        for (const child of this.children)
+            child.setFeature(feature);
+        return this;
+    }
+    addChild(child, index = this.children.length) {
+        this.children.splice(index, 0, child);
+        child.parent = this;
+        return child;
+    }
+    get isLeaf() {
+        return this.children.length === 0;
+    }
+    get successors() {
+        if (!this.isLeaf)
+            return this.children.filter((c, i) => i === 0 || c.isFork);
+        else {
+            if (this.isEnd)
+                return [];
+            const next = this.nextNonForkAncestorSibling;
+            if (next)
+                return [next];
+            return [];
+        }
+    }
+    get nextNonForkAncestorSibling() {
+        if (!this.parent)
+            return undefined;
+        const { nextSibling } = this;
+        if (nextSibling && !nextSibling.isFork)
+            return nextSibling;
+        return this.parent.nextNonForkAncestorSibling;
+    }
+    get nextSibling() {
+        if (!this.parent)
+            return undefined;
+        return this.parent.children[this.siblingIndex + 1];
+    }
+    get siblingIndex() {
+        var _a, _b;
+        return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.indexOf(this)) !== null && _b !== void 0 ? _b : -1;
+    }
+    toString() {
+        return this.children
+            .map((c) => (c.isFork ? '+ ' : '- ') + c.toString())
+            .join('\n');
+    }
+    replaceWith(newBranch) {
+        if (!this.parent)
+            throw new Error('cannot replace root');
+        this.parent.children.splice(this.siblingIndex, 1, newBranch);
+        newBranch.parent = this.parent;
+        this.parent = undefined;
+        return this;
+    }
+}
+export class Step extends Branch {
+    constructor(action, responses = [], children, isFork = false) {
+        super(children);
+        this.action = action;
+        this.responses = responses;
+        this.isFork = isFork;
+    }
+    get phrases() {
+        return [this.action, ...this.responses];
+    }
+    toCode(cg) {
+        if (this.responses[0] instanceof ErrorResponse) {
+            cg.errorStep(this.action, this.responses[0].message);
+        }
+        else {
+            cg.step(this.action, this.responses);
+        }
+    }
+    setFeature(feature) {
+        this.action.setFeature(feature);
+        for (const response of this.responses)
+            response.setFeature(feature);
+        return super.setFeature(feature);
+    }
+    headToString() {
+        return `${this.action}` + this.responses.map((r) => ` => ${r}`).join('');
+    }
+    toString() {
+        return this.headToString() + indent(super.toString());
+    }
+    get isEmpty() {
+        return this.phrases.every((phrase) => phrase.isEmpty);
+    }
+}
+export class State {
+    constructor(text = '') {
+        this.text = text;
+    }
+}
+export class Label {
+    constructor(text = '') {
+        this.text = text;
+    }
+    get isEmpty() {
+        return this.text === '';
+    }
+}
+export class Section extends Branch {
+    constructor(label, children, isFork = false) {
+        super(children);
+        this.label = label !== null && label !== void 0 ? label : new Label();
+        this.isFork = isFork;
+    }
+    toString() {
+        if (this.label.text === '')
+            return super.toString();
+        return this.label.text + ':' + indent(super.toString());
+    }
+    get isEmpty() {
+        return this.label.isEmpty;
+    }
+}
+export class Part {
+}
+export class Word extends Part {
+    constructor(text = '') {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+}
+export class Arg extends Part {
+}
+export class StringLiteral extends Arg {
+    constructor(text = '') {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return JSON.stringify(this.text);
+    }
+    toCode(cg) {
+        return cg.stringLiteral(this.text);
+    }
+    toDeclaration(cg, index) {
+        return cg.stringParamDeclaration(index);
+    }
+}
+export class CodeLiteral extends Arg {
+    constructor(src = '') {
+        super();
+        this.src = src;
+    }
+    toString() {
+        return '`' + this.src + '`';
+    }
+    toCode(cg) {
+        return cg.codeLiteral(this.src);
+    }
+    toDeclaration(cg, index) {
+        return cg.variantParamDeclaration(index);
+    }
+}
+export class Phrase {
+    constructor(content = [], docstring) {
+        this.content = content;
+        this.docstring =
+            docstring === undefined ? undefined : new StringLiteral(docstring);
+    }
+    setFeature(feature) {
+        this.feature = feature;
+    }
+    get keyword() {
+        return this.kind === 'action' ? 'When' : 'Then';
+    }
+    get args() {
+        return [...this.content, this.docstring].filter((c) => c instanceof Arg);
+    }
+    get isEmpty() {
+        return this.content.length === 0 && this.docstring === undefined;
+    }
+    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');
+    }
+    toSingleLineString() {
+        return [...this.content, ...(this.docstring ? [this.docstring] : [])]
+            .map((c) => c.toString())
+            .join(' ');
+    }
+}
+export class Action extends Phrase {
+    constructor() {
+        super(...arguments);
+        this.kind = 'action';
+    }
+    toCode(cg) {
+        if (!this.content.length && this.docstring === undefined)
+            return;
+        cg.phrase(this);
+    }
+}
+export class Response extends Phrase {
+    constructor() {
+        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;
+    }
+    toCode(cg) {
+        if (!this.content.length && this.docstring === undefined)
+            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;
+    }
+}
+export class Precondition extends Branch {
+    constructor(state = '') {
+        super();
+        this.state = new State();
+        this.state.text = state;
+    }
+    get isEmpty() {
+        return this.state.text === '';
+    }
+}
+export function makeTests(root) {
+    const routers = new Routers(root);
+    let tests = [];
+    let ic = routers.getIncompleteCount();
+    let newIc;
+    do {
+        const newTest = new Test(root, routers.nextWalk());
+        newIc = routers.getIncompleteCount();
+        if (newIc < ic)
+            tests.push(newTest);
+        ic = newIc;
+    } while (ic > 0);
+    // sort by order of appearance of the last branch
+    const branchIndex = new Map();
+    let i = 0;
+    function walk(branch) {
+        branchIndex.set(branch, i++);
+        for (const child of branch.children)
+            walk(child);
+    }
+    walk(root);
+    tests = tests.filter((t) => t.steps.length > 0);
+    tests.sort((a, b) => branchIndex.get(a.last) - branchIndex.get(b.last));
+    tests.forEach((test, i) => (test.testNumber = `T${i + 1}`));
+    return tests;
+}
+export class Test {
+    constructor(root, branches) {
+        this.root = root;
+        this.branches = branches;
+        this.branches = this.branches.filter((b) => !b.isEmpty);
+        this.labels = this.branches
+            .filter((b) => b instanceof Section)
+            .filter((s) => !s.isEmpty)
+            .map((s) => s.label.text);
+    }
+    get steps() {
+        return this.branches.filter((b) => b instanceof Step);
+    }
+    get last() {
+        return this.steps[this.steps.length - 1];
+    }
+    get name() {
+        return `${[this.testNumber, ...this.labels].join(' - ')}`;
+    }
+    toCode(cg) {
+        cg.test(this);
+    }
+    toString() {
+        return `+ ${this.name}:\n${this.steps
+            .map((s) => `  - ${s.headToString()}`)
+            .join('\n')}`;
+    }
+}
+export function makeGroups(tests) {
+    if (tests.length === 0)
+        return [];
+    if (tests[0].labels.length === 0)
+        return [tests[0], ...makeGroups(tests.slice(1))];
+    const name = tests[0].labels[0];
+    let count = tests.findIndex((t) => t.labels[0] !== name);
+    if (count === -1)
+        count = tests.length;
+    if (count === 1)
+        return [tests[0], ...makeGroups(tests.slice(1))];
+    tests.slice(0, count).forEach((test) => test.labels.shift());
+    return [
+        new TestGroup(name, makeGroups(tests.slice(0, count))),
+        ...makeGroups(tests.slice(count)),
+    ];
+}
+export class TestGroup {
+    constructor(name, items) {
+        this.name = name;
+        this.items = items;
+    }
+    toString() {
+        return `+ ${this.name}:` + indent(this.items.join('\n'));
+    }
+    toCode(cg) {
+        cg.testGroup(this);
+    }
+}
+function indent(s) {
+    if (!s)
+        return '';
+    return ('\n' +
+        s
+            .split('\n')
+            .map((l) => '  ' + l)
+            .join('\n'));
+}

package/optimizations/autoLabel/autoLabel.js

@@ -0,0 +1,15 @@
+import { Label, Section, Step } from "../../model/model.js";
+export function autoLabel(s) {
+    const forks = s.children.filter((c, i) => c.isFork || i === 0);
+    if (forks.length > 1) {
+        forks
+            .filter((c) => c instanceof Step)
+            .forEach((c) => {
+            const label = c.action.toSingleLineString();
+            const autoSection = new Section(new Label(label), [], c.isFork);
+            c.replaceWith(autoSection);
+            autoSection.addChild(c);
+        });
+    }
+    s.children.forEach((c) => autoLabel(c));
+}

package/package.json

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

package/parser/lexer.js

@@ -0,0 +1,4 @@
+import { buildLexer } from 'typescript-parsec';
+import rules from './lexer_rules.js';
+export { T } from './lexer_rules.js';
+export const lexer = buildLexer(rules);

package/parser/lexer_rules.js

@@ -0,0 +1,62 @@
+export var T;
+(function (T) {
+    T["Newline"] = "newline";
+    T["Comment"] = "comment";
+    /** the => */
+    T["ResponseArrow"] = "=>";
+    T["ErrorMark"] = "!!";
+    T["Words"] = "words";
+    T["Minus"] = "-";
+    T["Plus"] = "+";
+    T["Colon"] = ":";
+    T["Space"] = "space";
+    T["OpeningBracket"] = "[";
+    T["ClosingBracket"] = "]";
+    T["DoubleQuoteString"] = "double-quote string";
+    T["UnclosedDoubleQuoteString"] = "unclosed double-quote string";
+    T["BacktickString"] = "backtick string";
+    T["UnclosedBacktickString"] = "unclosed backtick string";
+    T["InvalidEmptyBacktickString"] = "invalid empty backtick string";
+    T["InvalidWhitespace"] = "invalid whitespace";
+    T["InvalidTab"] = "invalid tab";
+    T["MultilineString"] = "multiline string";
+    T["InvalidMultilineStringMark"] = "invalid multiline string mark";
+})(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],
+    [
+        true,
+        /^(?!\s|=>|!!|- |\+ |[\[\]"`|]).+?(?=[\[\]"`|]|\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,
+        T.DoubleQuoteString,
+    ],
+    [
+        true,
+        /^"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*/g,
+        T.UnclosedDoubleQuoteString,
+    ],
+    [true, /^``/g, T.InvalidEmptyBacktickString],
+    [true, /^`[^`]+`/g, T.BacktickString],
+    [true, /^`[^`]*/g, T.UnclosedBacktickString],
+    [true, /^\|(?: .*|(?=\n|$))/g, T.MultilineString],
+    [true, /^\|[^ ]/g, T.InvalidMultilineStringMark],
+];
+export default rules;

package/parser/parser.js

@@ -0,0 +1,78 @@
+import { alt_sc, apply, expectEOF, expectSingleResult, kright, opt_sc, rep_sc, seq, tok, list_sc, kleft, kmid, fail, } from 'typescript-parsec';
+import { T, lexer } from "./lexer.js";
+import { Action, Response, CodeLiteral, StringLiteral, Section, Step, Word, Label, ErrorResponse, } from "../model/model.js";
+export function parse(input, production = TEST_DESIGN) {
+    const tokens = lexer.parse(input);
+    return expectSingleResult(expectEOF(production.parse(tokens)));
+}
+export const SPACES = rep_sc(tok(T.Space));
+export const NEWLINES = list_sc(tok(T.Newline), SPACES); // 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), SPACES)), (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, SPACES)), opt_sc(kright(opt_sc(NEWLINES), kright(SPACES, 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), SPACES), tok(T.ResponseArrow), SPACES);
+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, SPACES), tok(T.Colon)), (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(SPACES, 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]) => ({
+    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) => {
+    const startDent = 0;
+    let dent = startDent;
+    const root = new Section(new Label(''));
+    let parent = root;
+    for (const { line, start } of 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}`);
+        }
+        else if (d > dent + 1) {
+            throw new Error(`invalid indent ${d} at line ${start.pos.rowBegin}`);
+        }
+        else if (d === dent + 1) {
+            parent = parent.children[parent.children.length - 1];
+            ++dent;
+        }
+        else if (d < startDent) {
+            throw new Error(`invalid indent ${d} at line ${start.pos.rowBegin}`);
+        }
+        else
+            while (d < dent) {
+                parent = parent.parent;
+                --dent;
+            }
+        parent.addChild(branch);
+    }
+    return root;
+}), rep_sc(NEWLINES));
+function inputText(start, end) {
+    let text = '';
+    let t = start;
+    while (t && t !== end) {
+        text += t.text;
+        t = t.next;
+    }
+    return text;
+}

package/vitest/index.js

@@ -0,0 +1,9 @@
+import { watchFiles } from "../cli/watch.js";
+export default function harmonyPlugin({ watchDir, }) {
+    return {
+        name: 'harmony',
+        configureServer(server) {
+            watchFiles([`${watchDir}/**/*.harmony`]);
+        },
+    };
+}

package/compile.js

@@ -1,14 +0,0 @@
-import { NodeTest } from './languages/JavaScript.js';
-import { OutFile } from './outFile.js';
-import { parse } from './syntax.js';
-import { stepsFileName, testFileName } from './filenames/filenames.js';
-export function compileFeature(fileName, src) {
-    const feature = parse({ fileName, src });
-    const testFn = testFileName(fileName);
-    const testFile = new OutFile(testFn);
-    const stepsFn = stepsFileName(fileName);
-    const stepsFile = new OutFile(stepsFn);
-    const cg = new NodeTest(testFile, stepsFile);
-    feature.toCode(cg);
-    return { outFile: testFile, stepsFile };
-}

package/config.js

@@ -1 +0,0 @@
-export {};

package/frameworks/Gherkin.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gherkin = void 0;
-class Gherkin {
-    constructor(outFile) {
-        this.outFile = outFile;
-    }
-    feature(name, tests) {
-        this.outFile.print(`Feature: ${name}`);
-        this.outFile.print('');
-        this.outFile.indent(() => {
-            for (const test of tests) {
-                test.toCode(this);
-            }
-        });
-    }
-    test(t) {
-        this.outFile.print(`Scenario: ${t.name}`);
-        this.outFile.indent(() => {
-            for (const step of t.steps) {
-                step.toCode(this);
-            }
-        });
-        this.outFile.print('');
-    }
-    phrase(p) {
-        this.outFile.print(`${p.keyword} ${p.text} || ${p.feature}`);
-        if (p.docstring !== undefined) {
-            this.outFile.indent(() => {
-                this.outFile.print(`"""`);
-                this.outFile.print(...p.docstring.split('\n'));
-                this.outFile.print(`"""`);
-            });
-        }
-    }
-}
-exports.Gherkin = Gherkin;

package/frameworks/NodeTest.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeTest = void 0;
-class NodeTest {
-    constructor(outFile) {
-        this.outFile = outFile;
-        this.framework = 'vitest';
-    }
-    feature(feature) {
-        if (this.framework === 'vitest') {
-            this.outFile.print(`import { test, expect } from 'vitest';`);
-        }
-        this.outFile.print(feature.prelude);
-        for (const test of feature.tests) {
-            test.toCode(this);
-        }
-    }
-    test(t) {
-        this.outFile.print(`test('${t.name}', async () => {`);
-        this.outFile.indent(() => {
-            for (const step of t.steps) {
-                step.toCode(this);
-            }
-        });
-        this.outFile.print('})');
-        this.outFile.print('');
-    }
-    phrase(p) {
-        var _a;
-        this.outFile.loc(p).print('/// ' + p.text);
-        const code = (_a = p.definition()) !== null && _a !== void 0 ? _a : `throw 'Not defined: ' + ${JSON.stringify(p.text)};`;
-        this.outFile.print(...code.split('\n'));
-    }
-}
-exports.NodeTest = NodeTest;