harmonyc 0.18.0 → 0.19.0

package/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cli/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { compileFiles } from "../compiler/compiler.js";
+import { parseArgs } from 'node:util';
+import { watchFiles } from "./watch.js";
+import { run, runWatch } from "./run.js";
+const args = parseArgs({
+    options: {
+        help: { type: 'boolean' },
+        watch: { type: 'boolean', short: 'w' },
+        run: { type: 'boolean', short: 'r' },
+    },
+    allowPositionals: true,
+});
+if (args.positionals.length === 0 || args.values.help) {
+    console.error('Usage: harmonyc <input files glob pattern>');
+    process.exit(1);
+}
+;
+(async () => {
+    if (args.values.watch) {
+        const outFns = await watchFiles(args.positionals);
+        if (args.values.run) {
+            runWatch(outFns);
+        }
+    }
+    else {
+        const { outFns } = await compileFiles(args.positionals);
+        if (args.values.run) {
+            run(outFns);
+        }
+    }
+})();

package/cli/run.d.ts

@@ -0,0 +1,2 @@
+export declare function run(patterns: string[]): void;
+export declare function runWatch(patterns: string[]): void;

package/cli/run.js

@@ -0,0 +1,21 @@
+import { exec, spawn } from 'child_process';
+function runCommand(patterns) {
+    return `npx vitest run ${args(patterns)}`;
+}
+function runWatchCommand(patterns) {
+    return `npx vitest ${args(patterns)}`;
+}
+function args(patterns) {
+    return patterns.map((s) => JSON.stringify(s)).join(' ');
+}
+export function run(patterns) {
+    var _a, _b;
+    const cmd = runCommand(patterns);
+    const p = exec(cmd, { cwd: process.cwd() });
+    (_a = p.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
+    (_b = p.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
+}
+export function runWatch(patterns) {
+    const cmd = runWatchCommand(patterns);
+    spawn(cmd, { cwd: process.cwd(), stdio: 'inherit', shell: true });
+}

package/cli/watch.d.ts

@@ -0,0 +1 @@
+export declare function watchFiles(patterns: string[]): Promise<string[]>;

package/cli/watch.js

@@ -0,0 +1,35 @@
+import Watcher from 'watcher';
+import { compileFile, compileFiles } from "../compiler/compiler.js";
+export async function watchFiles(patterns) {
+    const { fns, outFns } = await compileFiles(patterns);
+    for (const file of fns) {
+        const watcher = new Watcher(file, { debounce: 20, ignoreInitial: true });
+        watcher.on('all', async () => {
+            var _a;
+            try {
+                await compileFile(file);
+            }
+            catch (e) {
+                process.stdout.write(`\n`);
+                console.log((_a = e.message) !== null && _a !== void 0 ? _a : e);
+                process.stdout.write(`\n`);
+            }
+            logger.log(`Compiled ${file}`);
+        });
+    }
+    return outFns;
+}
+const logger = {
+    last: '',
+    n: 0,
+    log(msg) {
+        if (msg === this.last) {
+            process.stdout.write(`\r${msg} ${++this.n}x`);
+        }
+        else {
+            process.stdout.write(`\r${msg}`);
+            this.last = msg;
+            this.n = 1;
+        }
+    },
+};

package/code_generator/VitestGenerator.d.ts

@@ -0,0 +1,36 @@
+import { CompilerOptions } from '../compiler/compile.ts';
+import { Action, CodeGenerator, ErrorResponse, Feature, Phrase, PhraseMethod, Response, SaveToVariable, SetVariable, Test, TestGroup } from '../model/model.ts';
+import { OutFile } from './outFile.ts';
+export declare class VitestGenerator implements CodeGenerator {
+    private tf;
+    private sourceFileName;
+    private opts;
+    static error(message: string, stack: string): string;
+    framework: string;
+    phraseFns: Map<string, Phrase>;
+    currentFeatureName: string;
+    featureClassName: string;
+    phraseMethods: PhraseMethod[];
+    constructor(tf: OutFile, sourceFileName: string, opts: CompilerOptions);
+    feature(feature: Feature): void;
+    testGroup(g: TestGroup): void;
+    featureVars: Map<string, string>;
+    resultCount: number;
+    test(t: Test): void;
+    errorStep(action: Action, errorResponse: ErrorResponse): void;
+    extraArgs: string[];
+    step(action: Action, responses: Response[]): void;
+    private declareFeatureVariables;
+    phrase(p: Phrase): void;
+    setVariable(action: SetVariable): void;
+    saveToVariable(s: SaveToVariable, what?: string): void;
+    stringLiteral(text: string, { withVariables }: {
+        withVariables: boolean;
+    }): string;
+    codeLiteral(src: string): string;
+    private paramName;
+    stringParamDeclaration(index: number): string;
+    variantParamDeclaration(index: number): string;
+    functionName(phrase: Phrase): string;
+    argPlaceholder(i: number): string;
+}

package/code_generator/VitestGenerator.js

@@ -0,0 +1,240 @@
+import { basename } from 'path';
+import { xyzab } from "../compiler/compile.js";
+import { Arg, Response, Word, } from "../model/model.js";
+const X = 'X'.codePointAt(0);
+const A = 'A'.codePointAt(0);
+export class VitestGenerator {
+    static error(message, stack) {
+        return `const e = new SyntaxError(${str(message)});
+    e.stack = undefined;
+    throw e;
+    ${stack ? `/* ${stack} */` : ''}`;
+    }
+    constructor(tf, sourceFileName, opts) {
+        this.tf = tf;
+        this.sourceFileName = sourceFileName;
+        this.opts = opts;
+        this.framework = 'vitest';
+        this.phraseFns = new Map();
+        this.currentFeatureName = '';
+        this.phraseMethods = [];
+        this.resultCount = 0;
+        this.extraArgs = [];
+    }
+    feature(feature) {
+        const phrasesModule = './' + basename(this.sourceFileName.replace(/\.harmony$/, '.phrases.js'));
+        const fn = (this.featureClassName =
+            this.currentFeatureName =
+                pascalCase(feature.name) + 'Phrases');
+        this.phraseFns = new Map();
+        // test file
+        if (this.framework === 'vitest') {
+            this.tf.print(`import { describe, test, expect } from "vitest";`);
+        }
+        if (feature.tests.length === 0) {
+            this.tf.print('');
+            this.tf.print(`describe.todo(${str(feature.name)});`);
+            return;
+        }
+        this.tf.print(`import ${fn} from ${str(phrasesModule)};`);
+        this.tf.print(``);
+        for (const item of feature.testGroups) {
+            item.toCode(this);
+        }
+        this.tf.print(``);
+        for (const ph of this.phraseFns.keys()) {
+            const p = this.phraseFns.get(ph);
+            const parameters = p.args.map((a, i) => {
+                const declaration = a.toDeclaration(this, i);
+                const parts = declaration.split(': ');
+                return {
+                    name: parts[0],
+                    type: parts[1] || 'any',
+                };
+            });
+            if (p instanceof Response) {
+                parameters.push({
+                    name: 'res',
+                    type: 'any',
+                });
+            }
+            this.phraseMethods.push({
+                name: ph,
+                parameters,
+            });
+        }
+    }
+    testGroup(g) {
+        this.tf.print(`describe(${str(g.label.text)}, () => {`, g.label.start, g.label.text);
+        this.tf.indent(() => {
+            for (const item of g.items) {
+                item.toCode(this);
+            }
+        });
+        this.tf.print('});');
+    }
+    test(t) {
+        var _a;
+        this.resultCount = 0;
+        this.featureVars = new Map();
+        // avoid shadowing this import name
+        this.featureVars.set(new Object(), this.currentFeatureName);
+        this.tf.print(`test(${str(t.name)}, async (context) => {`, (_a = t.lastStrain) === null || _a === void 0 ? void 0 : _a.start, t.testNumber);
+        this.tf.indent(() => {
+            this.tf.print(`context.task.meta.phrases ??= [];`);
+            for (const step of t.steps) {
+                step.toCode(this);
+            }
+        });
+        this.tf.print('});');
+    }
+    errorStep(action, errorResponse) {
+        this.declareFeatureVariables([action]);
+        this.tf.print(`await expect(async () => {`);
+        this.tf.indent(() => {
+            action.toCode(this);
+            this.tf.print(`context.task.meta.phrases.push(${str(errorResponse.toSingleLineString())});`);
+        });
+        this.tf.print(`}).rejects.toThrow(${(errorResponse === null || errorResponse === void 0 ? void 0 : errorResponse.message) !== undefined
+            ? str(errorResponse.message.text)
+            : ''});`);
+    }
+    step(action, responses) {
+        this.declareFeatureVariables([action, ...responses]);
+        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(() => {
+            action.toCode(this);
+            try {
+                this.extraArgs = [res];
+                for (const response of responses) {
+                    response.toCode(this);
+                }
+            }
+            finally {
+                this.extraArgs = [];
+            }
+        });
+    }
+    declareFeatureVariables(phrases) {
+        for (const p of phrases) {
+            const feature = p.feature.name;
+            let f = this.featureVars.get(feature);
+            if (!f) {
+                f = toId(feature, abbrev, this.featureVars);
+                this.tf.print(`const ${f} = new ${pascalCase(feature)}Phrases(context);`);
+            }
+        }
+    }
+    phrase(p) {
+        const phrasefn = this.functionName(p);
+        if (!this.phraseFns.has(phrasefn))
+            this.phraseFns.set(phrasefn, p);
+        const f = this.featureVars.get(p.feature.name);
+        const args = p.args.map((a) => a.toCode(this));
+        args.push(...this.extraArgs);
+        if (p instanceof Response && p.parts.length === 1 && p.saveToVariable) {
+            return this.saveToVariable(p.saveToVariable);
+        }
+        const name = p.toSingleLineString();
+        this.tf.print(`(context.task.meta.phrases.push(${str(p.toString())}),`);
+        if (p instanceof Response && p.saveToVariable) {
+            this.saveToVariable(p.saveToVariable, '');
+        }
+        this.tf.printn(`await ${f}.`);
+        this.tf.write(`${phrasefn}(${args.join(', ')})`, p.start, name);
+        this.tf.write(`);`);
+        this.tf.nl();
+    }
+    setVariable(action) {
+        this.tf.print(`(context.task.meta.variables ??= {})[${str(action.variableName)}] = ${action.value.toCode(this)};`);
+    }
+    saveToVariable(s, what = this.extraArgs[0] + ';') {
+        this.tf.print(`(context.task.meta.variables ??= {})[${str(s.variableName)}] = ${what}`.trimEnd());
+    }
+    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.replace(/\$\{([^\s}]+)\}/g, (_, x) => `context.task.meta.variables?.[${str(x)}]`);
+    }
+    paramName(index) {
+        return xyzab(index);
+    }
+    stringParamDeclaration(index) {
+        return `${this.paramName(index)}: string`;
+    }
+    variantParamDeclaration(index) {
+        return `${this.paramName(index)}: any`;
+    }
+    functionName(phrase) {
+        const { kind } = phrase;
+        let argIndex = -1;
+        return ((kind === 'response' ? 'Then_' : 'When_') +
+            (phrase.parts
+                .flatMap((c) => c instanceof Word
+                ? words(c.text).filter((x) => x)
+                : c instanceof Arg
+                    ? [this.argPlaceholder(++argIndex)]
+                    : [])
+                .join('_') || ''));
+    }
+    argPlaceholder(i) {
+        return typeof this.opts.argumentPlaceholder === 'function'
+            ? this.opts.argumentPlaceholder(i)
+            : this.opts.argumentPlaceholder;
+    }
+}
+function str(s) {
+    if (s.includes('\n'))
+        return '\n' + templateStr(s);
+    let r = JSON.stringify(s);
+    return r;
+}
+function templateStr(s) {
+    return '`' + s.replace(/([`$\\])/g, '\\$1') + '`';
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function toId(s, transform, previous) {
+    if (previous.has(s))
+        return previous.get(s);
+    let base = transform(s);
+    let id = base;
+    if ([...previous.values()].includes(id)) {
+        let i = 1;
+        while ([...previous.values()].includes(id + i))
+            i++;
+        id = base + i;
+    }
+    previous.set(s, id);
+    return id;
+}
+function words(s) {
+    return s.split(/[^0-9\p{L}]+/gu);
+}
+function pascalCase(s) {
+    return words(s).map(capitalize).join('');
+}
+function underscore(s) {
+    return words(s).join('_');
+}
+function abbrev(s) {
+    return words(s)
+        .map((x) => x.charAt(0).toUpperCase())
+        .join('');
+}

package/code_generator/outFile.d.ts

@@ -0,0 +1,20 @@
+import { SourceNode } from 'source-map-js';
+import { Location } from '../model/model.ts';
+export declare class OutFile {
+    name: string;
+    sourceFile: string;
+    level: number;
+    sm: SourceNode;
+    indentSpaces: number;
+    constructor(name: string, sourceFile: string);
+    indent(fn: () => void): void;
+    private get currentIndent();
+    clear(): void;
+    printn(line: string, start?: Location, name?: string, end?: Location): void;
+    print(line: string, start?: Location, name?: string, end?: Location): void;
+    write(line: string, start?: Location, name?: string, end?: Location): void;
+    nl(): void;
+    get sourceMap(): import("source-map-js").RawSourceMap;
+    get valueWithoutSourceMap(): string;
+    get value(): string;
+}

package/code_generator/outFile.js

@@ -0,0 +1,60 @@
+import { SourceNode } from 'source-map-js';
+export class OutFile {
+    constructor(name, sourceFile) {
+        this.name = name;
+        this.sourceFile = sourceFile;
+        this.level = 0;
+        this.indentSpaces = 2;
+        this.sm = new SourceNode(0, 0, sourceFile);
+    }
+    indent(fn) {
+        this.level++;
+        try {
+            fn();
+        }
+        finally {
+            this.level--;
+        }
+    }
+    get currentIndent() {
+        return ' '.repeat(this.level * this.indentSpaces);
+    }
+    clear() {
+        this.sm = new SourceNode(0, 0, this.sourceFile);
+    }
+    printn(line, start, name, end) {
+        this.write(this.currentIndent + line, start, name, end);
+    }
+    print(line, start, name, end) {
+        this.write(this.currentIndent + line + '\n', start, name, end);
+    }
+    write(line, start, name, end) {
+        const chunk = line;
+        if (start) {
+            this.sm.add(new SourceNode(start.line, start.column, this.sourceFile, chunk, name));
+        }
+        else {
+            this.sm.add(new SourceNode(null, null, null, chunk));
+        }
+        if (end) {
+            this.sm.add(new SourceNode(end.line, end.column, this.sourceFile));
+        }
+    }
+    nl() {
+        this.write('\n');
+    }
+    get sourceMap() {
+        return this.sm.toStringWithSourceMap({ file: this.name }).map.toJSON();
+    }
+    get valueWithoutSourceMap() {
+        return this.sm.toString();
+    }
+    get value() {
+        const { code, map } = this.sm.toStringWithSourceMap({ file: this.name });
+        let res = code;
+        res +=
+            `\n//# sour` + // not for this file ;)
+                `ceMappingURL=data:application/json,${encodeURIComponent(map.toString())}`;
+        return res;
+    }
+}

package/code_generator/test_phrases.d.ts

@@ -0,0 +1,11 @@
+export declare class TestPhrases {
+    private context;
+    constructor(context: any);
+    When_goodbye(): void;
+    When_hello(): string;
+    When_greet_X(name: string): void;
+    Then_X_is_Y(x: string, y: string): Promise<void>;
+    Then_last_char(s: string): string;
+    Then_last_char_of_greeting(): any;
+    Then_X(s: string, r: string): void;
+}

package/code_generator/test_phrases.js

@@ -0,0 +1,27 @@
+import { expect } from 'vitest';
+export class TestPhrases {
+    constructor(context) {
+        this.context = context;
+    }
+    When_goodbye() {
+        throw new Error('Goodbye, World!');
+    }
+    When_hello() {
+        return (this.context.task.meta.greeting = 'Hello!');
+    }
+    When_greet_X(name) {
+        this.context.task.meta.greeting = `Hello, ${name}!`;
+    }
+    async Then_X_is_Y(x, y) {
+        expect(x).toBe(y);
+    }
+    Then_last_char(s) {
+        return s.slice(-1);
+    }
+    Then_last_char_of_greeting() {
+        return this.context.task.meta.greeting.slice(-1);
+    }
+    Then_X(s, r) {
+        expect(s).toBe(r);
+    }
+}

package/compiler/compile.d.ts

@@ -0,0 +1,16 @@
+import { OutFile } from '../code_generator/outFile.ts';
+export interface CompilerOptions {
+    argumentPlaceholder: string | ((index: number) => string);
+}
+export interface CompiledFeature {
+    name: string;
+    code: Record<string, string>;
+}
+export declare function XYZAB(index: number): string;
+export declare function xyzab(index: number): string;
+export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
+export declare function compileFeature(fileName: string, src: string, opts?: Partial<CompilerOptions>): {
+    outFile: OutFile;
+    phraseMethods: import("../model/model.ts").PhraseMethod[];
+    featureClassName: string;
+};

package/compiler/compile.js

@@ -0,0 +1,50 @@
+import { basename } from 'node:path';
+import { VitestGenerator } from "../code_generator/VitestGenerator.js";
+import { OutFile } from "../code_generator/outFile.js";
+import { base, testFileName } from "../filenames/filenames.js";
+import { Feature } from "../model/model.js";
+import { autoLabel } from "../optimizations/autoLabel/autoLabel.js";
+import { parse } from "../parser/parser.js";
+const X = 'X'.codePointAt(0);
+const A = 'A'.codePointAt(0);
+const x = 'x'.codePointAt(0);
+const a = 'a'.codePointAt(0);
+export function XYZAB(index) {
+    return String.fromCodePoint(A + ((X - A + index) % 26));
+}
+export function xyzab(index) {
+    return String.fromCodePoint(a + ((x - a + index) % 26));
+}
+export const DEFAULT_COMPILER_OPTIONS = {
+    argumentPlaceholder: XYZAB,
+};
+export function compileFeature(fileName, src, opts = {}) {
+    const feature = new Feature(basename(base(fileName)));
+    try {
+        feature.root = parse(src);
+    }
+    catch (e) {
+        if (e.pos && e.errorMessage) {
+            e.message =
+                e.stack = `Error in ${fileName}:${e.pos.rowBegin}:${e.pos.columnBegin}: ${e.errorMessage}`;
+        }
+        else {
+            e.stack = `Error in ${fileName}: ${e.stack}`;
+        }
+        throw e;
+    }
+    feature.root.setFeature(feature);
+    autoLabel(feature.root);
+    const testFn = testFileName(fileName);
+    const testFile = new OutFile(testFn, fileName);
+    const cg = new VitestGenerator(testFile, fileName, {
+        ...DEFAULT_COMPILER_OPTIONS,
+        ...opts,
+    });
+    feature.toCode(cg);
+    return {
+        outFile: testFile,
+        phraseMethods: cg.phraseMethods,
+        featureClassName: cg.featureClassName,
+    };
+}

package/compiler/compiler.d.ts

@@ -0,0 +1,8 @@
+export declare function compileFiles(pattern: string | string[]): Promise<{
+    fns: string[];
+    outFns: string[];
+}>;
+export declare function compileFile(fn: string): Promise<{
+    outFile: import("../code_generator/outFile.ts").OutFile;
+} | undefined>;
+export declare function preprocess(src: string): string;

package/compiler/compiler.js

@@ -0,0 +1,39 @@
+import glob from 'fast-glob';
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { compileFeature } from "./compile.js";
+export async function compileFiles(pattern) {
+    var _a;
+    const fns = await glob(pattern);
+    if (!fns.length)
+        throw new Error(`No files found for pattern: ${String(pattern)}`);
+    const results = await Promise.allSettled(fns.map((fn) => compileFile(fn)));
+    const compiled = results.flatMap((r) => r.status === 'fulfilled' ? [r.value] : []);
+    const errored = results.flatMap((r) => r.status === 'rejected' && r.reason ? [r.reason] : []);
+    for (const error of errored) {
+        console.error((_a = error.message) !== null && _a !== void 0 ? _a : error);
+    }
+    console.log(`Compiled ${compiled.length} file${compiled.length === 1 ? '' : 's'}.`);
+    const features = compiled.filter((f) => f !== undefined);
+    return { fns, outFns: features.map((f) => f.outFile.name) };
+}
+export async function compileFile(fn) {
+    fn = resolve(fn);
+    const src = preprocess(readFileSync(fn, 'utf8').toString());
+    try {
+        const { outFile } = compileFeature(fn, src);
+        writeFileSync(outFile.name, outFile.value);
+        return { outFile };
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+export function preprocess(src) {
+    // strip BOM
+    if (src.charCodeAt(0) === 0xfeff) {
+        src = src.slice(1);
+    }
+    src = src.replace(/\r\n?/g, '\n');
+    return src;
+}

package/filenames/filenames.d.ts

@@ -0,0 +1,3 @@
+export declare function base(fn: string): string;
+export declare function testFileName(fn: string): string;
+export declare function phrasesFileName(fn: string): string;

package/filenames/filenames.js

@@ -0,0 +1,17 @@
+import glob from 'fast-glob';
+const { globSync, convertPathToPattern } = glob;
+export function base(fn) {
+    return fn.replace(/\.harmony(\.\w+)?$/i, '');
+}
+export function testFileName(fn) {
+    return base(fn) + '.test.mjs';
+}
+export function phrasesFileName(fn) {
+    const baseFn = base(fn);
+    const pattern = convertPathToPattern(baseFn);
+    const existing = globSync(`${pattern}.phrases.{tsx,jsx,ts,js}`);
+    if (existing.length) {
+        return existing.sort().at(-1);
+    }
+    return `${baseFn}.phrases.ts`;
+}

package/model/Router.d.ts

@@ -0,0 +1,22 @@
+import type { Branch } from './model.ts';
+export declare class Router<N> {
+    outs: N[];
+    index: number;
+    random: () => number;
+    started: Set<N>;
+    covered: Set<N>;
+    constructor(outs: N[], seed?: string);
+    next(): N;
+    get incompleteCount(): number;
+}
+type N = Branch;
+export declare class Routers {
+    private root;
+    routers: Map<Branch, Router<Branch>>;
+    constructor(root: N);
+    discover(branch: N): void;
+    get(branch: N): Router<Branch>;
+    nextWalk(): Branch[];
+    getIncompleteCount(): number;
+}
+export {};