harmonyc 0.18.0 → 0.19.0

package/parser/lexer_rules.d.ts

@@ -0,0 +1,33 @@
+export declare enum T {
+    Newline = "newline",
+    Comment = "comment",
+    /** the => */
+    ResponseArrow = "=>",
+    ErrorMark = "!!",
+    Words = "words",
+    Minus = "-",
+    Plus = "+",
+    Colon = ":",
+    Space = "space",
+    OpeningBracket = "[",
+    ClosingBracket = "]",
+    OpeningBrace = "{",
+    ClosingBrace = "}",
+    And = "&",
+    Slash = "/",
+    Semicolon = ";",
+    DoubleQuoteString = "double-quote string",
+    UnclosedDoubleQuoteString = "unclosed double-quote string",
+    BacktickString = "backtick string",
+    UnclosedBacktickString = "unclosed backtick string",
+    InvalidEmptyBacktickString = "invalid empty backtick string",
+    InvalidWhitespace = "invalid whitespace",
+    InvalidTab = "invalid tab",
+    MultilineString = "multiline string",
+    InvalidMultilineStringMark = "invalid multiline string mark",
+    Variable = "variable",
+    InvalidEmptyVariable = "invalid empty variable",
+    UnclosedVariable = "unclosed variable"
+}
+declare const rules: [boolean, RegExp, T][];
+export default rules;

package/parser/lexer_rules.js

@@ -0,0 +1,74 @@
+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["OpeningBrace"] = "{";
+    T["ClosingBrace"] = "}";
+    T["And"] = "&";
+    T["Slash"] = "/";
+    T["Semicolon"] = ";";
+    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["Variable"] = "variable";
+    T["InvalidEmptyVariable"] = "invalid empty variable";
+    T["UnclosedVariable"] = "unclosed variable";
+})(T || (T = {}));
+const rules = [
+    // false = ignore token
+    // 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.OpeningBrace],
+    [true, /\}/y, T.ClosingBrace],
+    [true, /\//y, T.Slash],
+    [true, /&/y, T.And],
+    [true, /;/y, T.Semicolon],
+    [true, /!!/y, T.ErrorMark],
+    [true, /=>/y, T.ResponseArrow],
+    [
+        true,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*"/y,
+        T.DoubleQuoteString,
+    ],
+    [
+        true,
+        /"(?:[^"\\\n]|\\(?:[bfnrtv"\\/]|u[0-9a-fA-F]{4}))*/y,
+        T.UnclosedDoubleQuoteString,
+    ],
+    [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.d.ts

@@ -0,0 +1,18 @@
+import type { Parser, ParserOutput, Token } from 'typescript-parsec';
+import { Action, CodeLiteral, Docstring, ErrorResponse, Label, Response, Section, SetVariable, Step, StringLiteral, Switch, Word } from '../model/model.ts';
+import { T } from './lexer.ts';
+export declare function parse(input: string): Section;
+export declare function parse<T>(input: string, production: Parser<any, T>): T;
+export declare const NEWLINES: Parser<T, Token<T>[]>, WORDS: Parser<T, Word>, DOUBLE_QUOTE_STRING: Parser<T, StringLiteral>, BACKTICK_STRING: Parser<T, CodeLiteral>, DOCSTRING: Parser<T, Docstring>, ERROR_MARK: Parser<T, Token<T>>, VARIABLE: Parser<T, string>, SIMPLE_PART: Parser<T, Word | StringLiteral | Docstring | CodeLiteral>, SWITCH: Parser<T, Switch>, BRACES: Parser<T, Switch>, PART: Parser<T, Word | Switch | StringLiteral | Docstring | CodeLiteral>, PHRASE: Parser<T, (Word | Switch | StringLiteral | Docstring | CodeLiteral)[]>, ARG: Parser<T, StringLiteral | Docstring | CodeLiteral>, SET_VARIABLE: Parser<T, SetVariable>, ACTION: Parser<T, Action | SetVariable>, RESPONSE: Parser<T, Response>, ERROR_RESPONSE: Parser<T, ErrorResponse>, SAVE_TO_VARIABLE: Parser<T, Response>, ARROW: Parser<T, Token<T>>, RESPONSE_ITEM: Parser<T, Response | ErrorResponse>, STEP: Parser<T, Step>, LABEL: Parser<T, Label>, SECTION: Parser<T, Section>, BRANCH: Parser<T, Section | Step>, // section first, to make sure there is no colon after step
+DENTS: Parser<T, {
+    dent: number;
+    isFork: boolean;
+}>, NODE: Parser<T, {
+    dent: number;
+    branch: Section | Step;
+}>, ANYTHING_BUT_NEWLINE: {
+    parse(token: Token<T> | undefined): ParserOutput<T, Token<T>>;
+}, TEXT: Parser<T, undefined>, LINE: Parser<T, {
+    dent: number;
+    branch: Section | Step;
+} | undefined>, TEST_DESIGN: Parser<T, Section>;

package/parser/parser.js

@@ -0,0 +1,76 @@
+import { alt_sc, apply, expectEOF, expectSingleResult, fail, kleft, kmid, kright, list_sc, nil, opt_sc, rep_sc, seq, tok, unableToConsumeToken, } from 'typescript-parsec';
+import { Action, CodeLiteral, Docstring, ErrorResponse, Label, Response, SaveToVariable, Section, SetVariable, Step, StringLiteral, Switch, Word, } from "../model/model.js";
+import { T, lexer } from "./lexer.js";
+export function parse(input, production = TEST_DESIGN) {
+    const tokens = lexer.parse(input);
+    return expectSingleResult(expectEOF(production.parse(tokens)));
+}
+function anythingBut(kind) {
+    return {
+        parse(token) {
+            if (token === undefined)
+                return { successful: false, error: unableToConsumeToken(token) };
+            if (token.kind === kind)
+                return { successful: false, error: unableToConsumeToken(token) };
+            return {
+                candidates: [
+                    {
+                        firstToken: token,
+                        nextToken: token.next,
+                        result: token,
+                    },
+                ],
+                successful: true,
+                error: undefined,
+            };
+        },
+    };
+}
+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)), SIMPLE_PART = alt_sc(WORDS, DOUBLE_QUOTE_STRING, BACKTICK_STRING, DOCSTRING), 
+//REPEATER = apply(
+//list_sc(rep_sc(SIMPLE_PART), tok(T.And)),
+//(cs) => new Repeater(cs)
+//),
+SWITCH = apply(list_sc(SIMPLE_PART, tok(T.Slash)), (cs) => new Switch(cs)), 
+//ROUTER = apply(list_sc(REPEATER, tok(T.Semicolon)), (cs) => new Router(cs)),
+BRACES = kmid(tok(T.OpeningBrace), SWITCH, tok(T.ClosingBrace)), PART = alt_sc(SIMPLE_PART, BRACES), 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_sc(SET_VARIABLE, apply(PHRASE, (parts, range) => new Action(parts).at(range))), RESPONSE = apply(seq(PHRASE, opt_sc(VARIABLE)), ([parts, variable], range) => new Response(parts, variable !== undefined ? new SaveToVariable(variable) : undefined).at(range)), 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 Response([], new SaveToVariable(variable))), ARROW = kright(opt_sc(NEWLINES), tok(T.ResponseArrow)), RESPONSE_ITEM = kright(ARROW, alt_sc(SAVE_TO_VARIABLE, ERROR_RESPONSE, RESPONSE)), 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, range) => new Label(words.map((w) => w.toString()).join(' ')).at(range)), SECTION = apply(LABEL, (text) => new Section(text)), BRANCH = apply(alt_sc(SECTION, STEP), (branch, range) => branch.at(range)), // 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,
+    };
+}), NODE = apply(seq(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
+    dent,
+    branch: branch.setFork(isFork),
+})), ANYTHING_BUT_NEWLINE = anythingBut(T.Newline), TEXT = apply(seq(tok(T.Words), rep_sc(ANYTHING_BUT_NEWLINE)), () => undefined), LINE = alt_sc(NODE, TEXT), TEST_DESIGN = kmid(rep_sc(NEWLINES), apply(opt_sc(list_sc(apply(LINE, (line, [start, end]) => ({ line, start, end })), NEWLINES)), (lines) => {
+    let dent;
+    const root = new Section(new Label(''));
+    let parent = root;
+    for (const { line, start } of lines !== null && lines !== void 0 ? lines : []) {
+        if (line === undefined)
+            continue;
+        const { dent: d, branch } = line;
+        if (dent === undefined) {
+            if (d !== 0)
+                throw new Error(`invalid indent ${d} at line ${start.pos.rowBegin}: first step must not be indented`);
+            dent = 0;
+        }
+        else 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
+            while (d < dent) {
+                parent = parent.parent;
+                --dent;
+            }
+        parent.addChild(branch);
+    }
+    return root;
+}), rep_sc(NEWLINES));

package/phrases_assistant/phrases_assistant.d.ts

@@ -0,0 +1,13 @@
+import * as t from 'ts-morph';
+import { PhraseMethod } from '../model/model';
+export declare class PhrasesAssistant {
+    project: t.Project;
+    file: t.SourceFile;
+    clazz: t.ClassDeclaration;
+    constructor(content: string, className: string);
+    ensureMethods(methods: PhraseMethod[]): void;
+    ensureMethod(method: PhraseMethod): void;
+    addMethod(method: PhraseMethod): void;
+    sortMethods(): void;
+    toCode(): string;
+}

package/phrases_assistant/phrases_assistant.js

@@ -0,0 +1,146 @@
+import * as t from 'ts-morph';
+export class PhrasesAssistant {
+    constructor(content, className) {
+        var _a;
+        this.project = new t.Project({
+            useInMemoryFileSystem: true,
+        });
+        this.file = this.project.createSourceFile('filename.ts', content, {
+            overwrite: true,
+        });
+        const clazz = this.file.getClass(className);
+        if (!clazz) {
+            const defaultExport = this.file.getDefaultExportSymbol();
+            if (defaultExport) {
+                const decl = defaultExport.getDeclarations()[0];
+                if (t.Node.isClassDeclaration(decl)) {
+                    this.clazz = decl;
+                    this.clazz.rename(className);
+                }
+            }
+        }
+        else {
+            this.clazz = clazz;
+            if (!this.clazz.isDefaultExport()) {
+                this.clazz.setIsDefaultExport(true);
+            }
+        }
+        (_a = this.clazz) !== null && _a !== void 0 ? _a : (this.clazz = this.file.addClass({
+            name: className,
+            isDefaultExport: true,
+        }));
+    }
+    ensureMethods(methods) {
+        for (const method of methods) {
+            this.ensureMethod(method);
+        }
+        this.clazz
+            .getMethods()
+            .filter((m) => !methods.find((md) => md.name === m.getName()))
+            .forEach((m) => {
+            if (m.getStatements().length === 1 &&
+                m
+                    .getStatements()[0]
+                    .getText()
+                    .match(/throw new Error\(["']TODO /)) {
+                m.remove();
+            }
+        });
+        this.sortMethods();
+    }
+    ensureMethod(method) {
+        let existing = this.clazz.getMethod(method.name);
+        if (!existing) {
+            this.addMethod(method);
+        }
+    }
+    addMethod(method) {
+        const m = this.clazz.addMethod({
+            isAsync: true,
+            name: method.name,
+            parameters: method.parameters,
+            statements: [`throw new Error("TODO ${method.name}");`],
+        });
+        m.formatText({ indentSize: 2 });
+    }
+    sortMethods() {
+        const groups = ['When_', 'Then_'];
+        const members = this.clazz.getMembersWithComments();
+        const sorted = members.slice().sort((a, b) => {
+            const kindA = t.Node.isMethodDeclaration(a)
+                ? groups.findIndex((g) => a.getName().startsWith(g))
+                : -1;
+            const kindB = t.Node.isMethodDeclaration(b)
+                ? groups.findIndex((g) => b.getName().startsWith(g))
+                : -1;
+            if (kindA !== kindB) {
+                return kindA - kindB;
+            }
+            if (kindA === -1 && kindB === -1) {
+                return 0;
+            }
+            if (!t.Node.isMethodDeclaration(a) || !t.Node.isMethodDeclaration(b)) {
+                // never happens
+                return 0;
+            }
+            return a.getName() < b.getName() ? -1 : 1;
+        });
+        const moves = calculateMoves(members, sorted);
+        for (const move of moves) {
+            const method = members[move.fromIndex];
+            if (t.Node.isCommentClassElement(method)) {
+                // something went wrong
+                return;
+            }
+            method.setOrder(move.toIndex);
+            const [moved] = members.splice(move.fromIndex, 1);
+            members.splice(move.toIndex, 0, moved);
+        }
+    }
+    toCode() {
+        let s = this.file.getFullText();
+        // fix extra space
+        const closing = this.clazz.getEnd() - 1;
+        if (s.slice(closing - 2, closing + 1) === '\n }') {
+            s = s.slice(0, closing - 1) + s.slice(closing);
+        }
+        return s;
+    }
+}
+/**
+ * Calculates a set of move operations to transform one array into another.
+ * Both arrays must contain the same elements, just in different order.
+ *
+ * @param actual - The current array that needs to be reordered
+ * @param desired - The target array with the desired order
+ * @returns Array of move operations {fromIndex, toIndex} that transform actual into desired
+ */
+function calculateMoves(actual, desired) {
+    if (actual.length !== desired.length) {
+        throw new Error('Arrays must have the same length');
+    }
+    // Create a working copy to track changes
+    const working = [...actual];
+    const moves = [];
+    // For each position in the desired array
+    for (let targetIndex = 0; targetIndex < desired.length; targetIndex++) {
+        const targetElement = desired[targetIndex];
+        // Find where this element currently is in our working array
+        const currentIndex = working.indexOf(targetElement);
+        if (currentIndex === -1) {
+            throw new Error('Arrays must contain the same elements');
+        }
+        // If it's not in the right position, move it
+        if (currentIndex !== targetIndex) {
+            // Record the move operation
+            moves.push({
+                fromIndex: currentIndex,
+                toIndex: targetIndex,
+            });
+            // Apply the move to our working array
+            const [movedElement] = working.splice(currentIndex, 1);
+            working.splice(targetIndex, 0, movedElement);
+        }
+    }
+    return moves;
+}

package/util/indent.d.ts

@@ -0,0 +1 @@
+export declare const Indent: (n: number) => (lines: Iterable<string>) => Generator<string, void, unknown>;

package/util/indent.js

@@ -0,0 +1,5 @@
+export const Indent = (n) => function* indent(lines) {
+    for (const line of lines) {
+        yield ' '.repeat(n) + line;
+    }
+};

package/util/iterators.d.ts

@@ -0,0 +1 @@
+export declare function flatMap<T, R>(iterable: Iterable<T>, callback: (value: T) => Iterable<R>): Generator<R, void, undefined>;

package/util/iterators.js

@@ -0,0 +1,5 @@
+export function* flatMap(iterable, callback) {
+    for (const value of iterable) {
+        yield* callback(value);
+    }
+}

package/util/xmur3.d.ts

@@ -0,0 +1 @@
+export declare function xmur3(str: string): () => number;

package/util/xmur3.js

@@ -0,0 +1,12 @@
+// https://stackoverflow.com/revisions/47593316/25 by bryc (github.com/bryc)
+export function xmur3(str) {
+    let h = 1779033703 ^ str.length;
+    for (let i = 0; i < str.length; i++)
+        (h = Math.imul(h ^ str.charCodeAt(i), 3432918353)),
+            (h = (h << 13) | (h >>> 19));
+    return function () {
+        h = Math.imul(h ^ (h >>> 16), 2246822507);
+        h = Math.imul(h ^ (h >>> 13), 3266489909);
+        return (h ^= h >>> 16) >>> 0;
+    };
+}

package/vitest/index.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+import { CompilerOptions } from '../compiler/compile.ts';
+export interface HarmonyPluginOptions extends Partial<CompilerOptions> {
+    autoEditPhrases?: boolean;
+}
+export default function harmonyPlugin(opts?: HarmonyPluginOptions): Plugin;
+declare module 'vitest' {
+    interface TaskMeta {
+        phrases?: string[];
+    }
+}

package/vitest/index.js

@@ -0,0 +1,101 @@
+import { readFile, writeFile } from 'fs/promises';
+import c from 'tinyrainbow';
+import { compileFeature } from "../compiler/compile.js";
+import { preprocess } from "../compiler/compiler.js";
+import { PhrasesAssistant } from "../phrases_assistant/phrases_assistant.js";
+const DEFAULT_OPTIONS = {
+    autoEditPhrases: true,
+};
+export default function harmonyPlugin(opts = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...opts };
+    return {
+        name: 'harmony',
+        resolveId(id) {
+            if (id.endsWith('.harmony')) {
+                return id;
+            }
+        },
+        transform(code, id) {
+            if (!id.endsWith('.harmony'))
+                return null;
+            code = preprocess(code);
+            const { outFile, phraseMethods, featureClassName } = compileFeature(id, code, opts);
+            if (options.autoEditPhrases) {
+                void updatePhrasesFile(id, phraseMethods, featureClassName);
+            }
+            return {
+                code: outFile.valueWithoutSourceMap,
+                map: outFile.sourceMap,
+            };
+        },
+        config(config) {
+            var _a, _b;
+            var _c;
+            (_a = config.test) !== null && _a !== void 0 ? _a : (config.test = {});
+            (_b = (_c = config.test).reporters) !== null && _b !== void 0 ? _b : (_c.reporters = ['default']);
+            if (!Array.isArray(config.test.reporters)) {
+                config.test.reporters = [config.test.reporters];
+            }
+            config.test.reporters.splice(0, 0, new HarmonyReporter());
+        },
+    };
+}
+class HarmonyReporter {
+    onInit(ctx) {
+        this.ctx = ctx;
+    }
+    onCollected(files) {
+        this.files = files;
+    }
+    onTaskUpdate(packs) {
+        if (this.files)
+            for (const file of this.files)
+                addPhrases(file);
+    }
+    onFinished(files, errors) {
+        for (const file of files)
+            addPhrases(file);
+    }
+}
+function addPhrases(task, depth = 2) {
+    var _a, _b;
+    if ('tasks' in task) {
+        for (const child of task.tasks)
+            addPhrases(child, depth + 1);
+    }
+    else if (task.type === 'test' &&
+        ((_a = task.result) === null || _a === void 0 ? void 0 : _a.state) === 'fail' &&
+        ((_b = task.meta) === null || _b === void 0 ? void 0 : _b.hasOwnProperty('phrases')) &&
+        task.meta.phrases.length > 0) {
+        const x = task;
+        x.name +=
+            '\n' +
+                task.meta
+                    .phrases.map((step, i, a) => {
+                    const indent = '  '.repeat(depth);
+                    const failed = i === a.length - 1;
+                    const figure = failed ? c.red('×') : c.green('✓');
+                    return `${indent}${figure} ${step}`;
+                })
+                    .join('\n');
+        delete task.meta.phrases; // to make sure not to add them again
+    }
+}
+async function updatePhrasesFile(id, phraseMethods, featureClassName) {
+    try {
+        const phrasesFile = id.replace(/\.harmony$/, '.phrases.ts');
+        let phrasesFileContent = '';
+        try {
+            phrasesFileContent = await readFile(phrasesFile, 'utf-8');
+        }
+        catch {
+            // File doesn't exist
+        }
+        const pa = new PhrasesAssistant(phrasesFileContent, featureClassName);
+        pa.ensureMethods(phraseMethods);
+        await writeFile(phrasesFile, pa.toCode());
+    }
+    catch (e) {
+        console.error('Error updating phrases file:', e);
+    }
+}