harmonyc 0.18.0 → 0.18.1

package/model/model.js

@@ -0,0 +1,526 @@
+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 Node {
+    at([startToken, endToken]) {
+        while (startToken && startToken.kind === 'newline') {
+            startToken = startToken.next;
+        }
+        if (startToken) {
+            this.start = {
+                line: startToken.pos.rowBegin,
+                column: startToken.pos.columnBegin - 1,
+            };
+        }
+        if (startToken && endToken) {
+            let t = startToken;
+            while (t.next && t.next !== endToken) {
+                t = t.next;
+            }
+            this.end = {
+                line: t.pos.rowEnd,
+                column: t.pos.columnEnd - 1,
+            };
+        }
+        return this;
+    }
+    atSameAs(other) {
+        this.start = other.start;
+        this.end = other.end;
+        return this;
+    }
+}
+export class Branch extends Node {
+    constructor(children = []) {
+        super();
+        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;
+    }
+    switch(_i) {
+        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]);
+        }
+        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.phrases.join(' ');
+    }
+    toString() {
+        return this.headToString() + indent(super.toString());
+    }
+    get isEmpty() {
+        return this.phrases.every((phrase) => phrase.isEmpty);
+    }
+    switch(i) {
+        return new Step(this.action.switch(i), this.responses.map((r) => r.switch(i)));
+    }
+}
+export class State {
+    constructor(text = '') {
+        this.text = text;
+    }
+}
+export class Label extends Node {
+    constructor(text = '') {
+        super();
+        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 {
+    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 = '') {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+}
+export class Repeater extends Part {
+    constructor(choices) {
+        super();
+        this.choices = choices;
+    }
+    toString() {
+        return `{${this.choices.map((ps) => ps.join(' ')).join(' & ')}}`;
+    }
+    toSingleLineString() {
+        return `{${this.choices
+            .map((ps) => ps.map((p) => p.toSingleLineString()).join(' '))
+            .join(' & ')}}`;
+    }
+}
+export class Switch extends Part {
+    constructor(choices) {
+        super();
+        this.choices = choices;
+    }
+    toString() {
+        return `{ ${this.choices.join(' / ')} }`;
+    }
+    toSingleLineString() {
+        return `{ ${this.choices.map((c) => c.toSingleLineString()).join(' / ')} }`;
+    }
+}
+export class Router extends Part {
+    constructor(choices) {
+        super();
+        this.choices = choices;
+    }
+    toString() {
+        return `{ ${this.choices.join(' ; ')} }`;
+    }
+    toSingleLineString() {
+        return `{ ${this.choices.map((c) => c.toSingleLineString()).join(' ; ')} }`;
+    }
+}
+export class Arg extends Part {
+}
+export class StringLiteral extends Arg {
+    constructor(text = '') {
+        super();
+        this.text = text;
+    }
+    toString() {
+        return JSON.stringify(this.text);
+    }
+    toSingleLineString() {
+        return this.toString();
+    }
+    toCode(cg) {
+        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();
+        this.src = src;
+    }
+    toString() {
+        return '`' + this.src + '`';
+    }
+    toCode(cg) {
+        return cg.codeLiteral(this.src);
+    }
+    toDeclaration(cg, index) {
+        return cg.variantParamDeclaration(index);
+    }
+}
+export class Phrase extends Node {
+    constructor(parts) {
+        super();
+        this.parts = parts;
+    }
+    setFeature(feature) {
+        this.feature = feature;
+        return this;
+    }
+    get keyword() {
+        return this.kind === 'action' ? 'When' : 'Then';
+    }
+    get args() {
+        return this.parts.filter((c) => c instanceof Arg);
+    }
+    get isEmpty() {
+        return this.parts.length === 0;
+    }
+    toString() {
+        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.parts.map((p) => p.toSingleLineString()).join(' ');
+    }
+    switch(i) {
+        return new this.constructor(this.parts.map((p) => (p instanceof Switch ? p.choices[i] : p))).setFeature(this.feature);
+    }
+}
+export class Action extends Phrase {
+    constructor() {
+        super(...arguments);
+        this.kind = 'action';
+    }
+    toCode(cg) {
+        if (this.isEmpty)
+            return;
+        cg.phrase(this);
+    }
+}
+export class Response extends Phrase {
+    constructor(parts, saveToVariable) {
+        super([...parts, ...(saveToVariable ? [saveToVariable] : [])]);
+        this.saveToVariable = saveToVariable;
+        this.kind = 'response';
+    }
+    get isEmpty() {
+        return this.parts.length === 0 && !this.saveToVariable;
+    }
+    toString() {
+        return `=> ${super.toString()}`;
+    }
+    toSingleLineString() {
+        return `=> ${super.toSingleLineString()}`;
+    }
+    toCode(cg) {
+        if (this.isEmpty)
+            return;
+        cg.phrase(this);
+    }
+}
+export class ErrorResponse extends Response {
+    constructor(message) {
+        super(message ? [new DummyKeyword('!!'), message] : [new DummyKeyword('!!')]);
+        this.message = message;
+    }
+    toCode(cg) {
+        cg.errorStep;
+    }
+}
+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 Part {
+    constructor(variableName) {
+        super();
+        this.variableName = variableName;
+    }
+    toCode(cg) {
+        cg.saveToVariable(this);
+    }
+    toString() {
+        return `\${${this.variableName}}`;
+    }
+    get words() {
+        return [];
+    }
+}
+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(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));
+    resolveSwitches(tests);
+    tests.forEach((test, i) => (test.testNumber = `T${i + 1}`));
+    return tests;
+}
+function resolveSwitches(tests) {
+    for (let i = 0; i < tests.length; ++i) {
+        const test = tests[i];
+        const phrases = test.steps.flatMap((s) => s.phrases);
+        const switches = phrases.flatMap((p) => p.parts.filter((p) => p instanceof Switch));
+        if (switches.length === 0)
+            continue;
+        const count = switches[0].choices.length;
+        if (switches.some((s) => s.choices.length !== count)) {
+            throw new Error(`all switches in a test case must have the same number of choices: ${test.name} has ${switches.map((s) => s.choices.length)} choices`);
+        }
+        const newTests = switches[0].choices.map((_, j) => test.switch(j));
+        tests.splice(i, 1, ...newTests);
+        i += count - 1;
+    }
+}
+export class Test {
+    constructor(branches) {
+        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);
+    }
+    get steps() {
+        return this.branches.filter((b) => b instanceof Step);
+    }
+    get last() {
+        return this.steps.at(-1);
+    }
+    get lastStrain() {
+        // Find the last branch that has no forks after it
+        const lastForking = this.branches.length -
+            1 -
+            this.branches
+                .slice()
+                .reverse()
+                .findIndex((b) => b.successors.length > 1);
+        if (lastForking === this.branches.length)
+            return this.branches.at(0);
+        return this.branches.at(lastForking + 1);
+    }
+    get name() {
+        return `${[this.testNumber, ...this.labels.map((x) => x.text)].join(' - ')}`;
+    }
+    toCode(cg) {
+        cg.test(this);
+    }
+    toString() {
+        return `+ ${this.name}:\n${this.steps
+            .map((s) => `  - ${s.headToString()}`)
+            .join('\n')}`;
+    }
+    switch(j) {
+        return new Test(this.branches.map((b) => b.switch(j)));
+    }
+}
+export function makeGroups(tests) {
+    if (tests.length === 0)
+        return [];
+    if (tests[0].labels.length === 0)
+        return [tests[0], ...makeGroups(tests.slice(1))];
+    const label = tests[0].labels[0];
+    let count = tests.findIndex((t) => 
+    // using identity instead of text equality, which means identically named labels will not be grouped together
+    t.labels[0] !== label);
+    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(label, makeGroups(tests.slice(0, count))),
+        ...makeGroups(tests.slice(count)),
+    ];
+}
+export class TestGroup {
+    constructor(label, items) {
+        this.label = label;
+        this.items = items;
+    }
+    toString() {
+        return `+ ${this.label.text}:` + 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.d.ts

@@ -0,0 +1,2 @@
+import { Branch } from '../../model/model.ts';
+export declare function autoLabel(b: Branch): void;

package/optimizations/autoLabel/autoLabel.js

@@ -0,0 +1,19 @@
+import { Label, Section, Step } from "../../model/model.js";
+export function autoLabel(b) {
+    const forks = b.children.filter((c, i) => c.isFork || i === 0);
+    if (forks.length > 1) {
+        forks
+            .filter((child) => child instanceof Step)
+            .forEach((step) => {
+            const label = step.action.toSingleLineString();
+            const autoLabel = new Label(label);
+            autoLabel.atSameAs(step.action);
+            const autoSection = new Section(autoLabel, [], step.isFork);
+            // todo this is some redundancy with both section and label storing the position
+            autoSection.atSameAs(step);
+            step.replaceWith(autoSection);
+            autoSection.addChild(step);
+        });
+    }
+    b.children.forEach((c) => autoLabel(c));
+}

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {
     "harmonyc": "./cli.js"
   },
-  "files": [
-    "."
-  ],
   "exports": {
     "./vitest": {
       "types": "./vitest/index.d.ts",

package/parser/lexer.d.ts

@@ -0,0 +1,21 @@
+import { Token, Lexer, TokenPosition } from 'typescript-parsec';
+export { T } from './lexer_rules.js';
+declare class TokenImpl<T> implements Token<T> {
+    private readonly lexer;
+    private readonly input;
+    kind: T;
+    text: string;
+    pos: TokenPosition;
+    keep: boolean;
+    private nextToken;
+    constructor(lexer: LexerImpl<T>, input: string, kind: T, text: string, pos: TokenPosition, keep: boolean);
+    get next(): Token<T> | undefined;
+}
+declare class LexerImpl<T> implements Lexer<T> {
+    rules: [boolean, RegExp, T][];
+    constructor(rules: [boolean, RegExp, T][]);
+    parse(input: string): TokenImpl<T> | undefined;
+    parseNext(input: string, indexStart: number, rowBegin: number, columnBegin: number): TokenImpl<T> | undefined;
+    parseNextAvailable(input: string, index: number, rowBegin: number, columnBegin: number): TokenImpl<T> | undefined;
+}
+export declare const lexer: LexerImpl<import("./lexer_rules.js").T>;

package/parser/lexer.js

@@ -0,0 +1,123 @@
+import { TokenError } from 'typescript-parsec';
+import rules from './lexer_rules.js';
+export { T } from './lexer_rules.js';
+// 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);