harmonyc 0.18.1 → 0.19.0

package/code_generator/VitestGenerator.d.ts

@@ -1,14 +1,17 @@
-import { Action, CodeGenerator, ErrorResponse, Feature, Phrase, Response, SaveToVariable, SetVariable, Test, TestGroup } from '../model/model.ts';
+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 sf;
-    private _sourceFileName;
+    private sourceFileName;
+    private opts;
     static error(message: string, stack: string): string;
     framework: string;
     phraseFns: Map<string, Phrase>;
     currentFeatureName: string;
-    constructor(tf: OutFile, sf: OutFile, _sourceFileName: string);
+    featureClassName: string;
+    phraseMethods: PhraseMethod[];
+    constructor(tf: OutFile, sourceFileName: string, opts: CompilerOptions);
     feature(feature: Feature): void;
     testGroup(g: TestGroup): void;
     featureVars: Map<string, string>;
@@ -28,5 +31,6 @@ export declare class VitestGenerator implements CodeGenerator {
     private paramName;
     stringParamDeclaration(index: number): string;
     variantParamDeclaration(index: number): string;
+    functionName(phrase: Phrase): string;
+    argPlaceholder(i: number): string;
 }
-export declare function functionName(phrase: Phrase): string;

package/code_generator/VitestGenerator.js

@@ -1,5 +1,8 @@
 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)});
@@ -7,19 +10,22 @@ export class VitestGenerator {
     throw e;
     ${stack ? `/* ${stack} */` : ''}`;
     }
-    constructor(tf, sf, _sourceFileName) {
+    constructor(tf, sourceFileName, opts) {
         this.tf = tf;
-        this.sf = sf;
-        this._sourceFileName = _sourceFileName;
+        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.sf.name.replace(/.(js|ts)$/, ''));
-        const fn = (this.currentFeatureName = pascalCase(feature.name));
+        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') {
@@ -30,26 +36,33 @@ export class VitestGenerator {
             this.tf.print(`describe.todo(${str(feature.name)});`);
             return;
         }
-        this.tf.print(`import ${fn}Phrases from ${str(phrasesModule)};`);
+        this.tf.print(`import ${fn} from ${str(phrasesModule)};`);
         this.tf.print(``);
         for (const item of feature.testGroups) {
             item.toCode(this);
         }
         this.tf.print(``);
-        // phrases file
-        this.sf.print(`export default class ${pascalCase(feature.name)}Phrases {`);
-        this.sf.indent(() => {
-            for (const ph of this.phraseFns.keys()) {
-                const p = this.phraseFns.get(ph);
-                const params = p.args.map((a, i) => a.toDeclaration(this, i)).join(', ');
-                this.sf.print(`async ${ph}(${params}) {`);
-                this.sf.indent(() => {
-                    this.sf.print(`throw new Error(${str(`Pending: ${ph}`)});`);
+        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.sf.print(`}`);
             }
-        });
-        this.sf.print(`};`);
+            this.phraseMethods.push({
+                name: ph,
+                parameters,
+            });
+        }
     }
     testGroup(g) {
         this.tf.print(`describe(${str(g.label.text)}, () => {`, g.label.start, g.label.text);
@@ -124,7 +137,7 @@ export class VitestGenerator {
         }
     }
     phrase(p) {
-        const phrasefn = functionName(p);
+        const phrasefn = this.functionName(p);
         if (!this.phraseFns.has(phrasefn))
             this.phraseFns.set(phrasefn, p);
         const f = this.featureVars.get(p.feature.name);
@@ -139,7 +152,7 @@ export class VitestGenerator {
             this.saveToVariable(p.saveToVariable, '');
         }
         this.tf.printn(`await ${f}.`);
-        this.tf.write(`${functionName(p)}(${args.join(', ')})`, p.start, name);
+        this.tf.write(`${phrasefn}(${args.join(', ')})`, p.start, name);
         this.tf.write(`);`);
         this.tf.nl();
     }
@@ -159,7 +172,7 @@ export class VitestGenerator {
         return src.replace(/\$\{([^\s}]+)\}/g, (_, x) => `context.task.meta.variables?.[${str(x)}]`);
     }
     paramName(index) {
-        return 'xyz'.charAt(index) || `a${index + 1}`;
+        return xyzab(index);
     }
     stringParamDeclaration(index) {
         return `${this.paramName(index)}: string`;
@@ -167,6 +180,23 @@ export class VitestGenerator {
     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'))
@@ -208,14 +238,3 @@ function abbrev(s) {
         .map((x) => x.charAt(0).toUpperCase())
         .join('');
 }
-export function functionName(phrase) {
-    const { kind } = phrase;
-    return ((kind === 'response' ? 'Then_' : 'When_') +
-        (phrase.parts
-            .flatMap((c) => c instanceof Word
-            ? words(c.text).filter((x) => x)
-            : c instanceof Arg
-                ? ['']
-                : [])
-            .join('_') || ''));
-}

package/code_generator/test_phrases.d.ts

@@ -3,9 +3,9 @@ export declare class TestPhrases {
     constructor(context: any);
     When_goodbye(): void;
     When_hello(): string;
-    When_greet_(name: string): void;
-    Then__is_(x: string, y: string): Promise<void>;
+    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_(s: string, r: string): void;
+    Then_X(s: string, r: string): void;
 }

package/code_generator/test_phrases.js

@@ -9,10 +9,10 @@ export class TestPhrases {
     When_hello() {
         return (this.context.task.meta.greeting = 'Hello!');
     }
-    When_greet_(name) {
+    When_greet_X(name) {
         this.context.task.meta.greeting = `Hello, ${name}!`;
     }
-    async Then__is_(x, y) {
+    async Then_X_is_Y(x, y) {
         expect(x).toBe(y);
     }
     Then_last_char(s) {
@@ -21,7 +21,7 @@ export class TestPhrases {
     Then_last_char_of_greeting() {
         return this.context.task.meta.greeting.slice(-1);
     }
-    Then_(s, r) {
+    Then_X(s, r) {
         expect(s).toBe(r);
     }
 }

package/compiler/compile.d.ts

@@ -1,9 +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 compileFeature(fileName: string, src: 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;
-    phrasesFile: OutFile;
+    phraseMethods: import("../model/model.ts").PhraseMethod[];
+    featureClassName: string;
 };

package/compiler/compile.js

@@ -1,11 +1,24 @@
 import { basename } from 'node:path';
 import { VitestGenerator } from "../code_generator/VitestGenerator.js";
 import { OutFile } from "../code_generator/outFile.js";
-import { base, phrasesFileName, testFileName } from "../filenames/filenames.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";
-export function compileFeature(fileName, src) {
+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);
@@ -24,9 +37,14 @@ export function compileFeature(fileName, src) {
     autoLabel(feature.root);
     const testFn = testFileName(fileName);
     const testFile = new OutFile(testFn, fileName);
-    const phrasesFn = phrasesFileName(fileName);
-    const phrasesFile = new OutFile(phrasesFn, fileName);
-    const cg = new VitestGenerator(testFile, phrasesFile, fileName);
+    const cg = new VitestGenerator(testFile, fileName, {
+        ...DEFAULT_COMPILER_OPTIONS,
+        ...opts,
+    });
     feature.toCode(cg);
-    return { outFile: testFile, phrasesFile };
+    return {
+        outFile: testFile,
+        phraseMethods: cg.phraseMethods,
+        featureClassName: cg.featureClassName,
+    };
 }

package/compiler/compiler.d.ts

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

package/compiler/compiler.js

@@ -1,8 +1,6 @@
 import glob from 'fast-glob';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { readFileSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
-import { VitestGenerator } from "../code_generator/VitestGenerator.js";
-import { testFileName } from "../filenames/filenames.js";
 import { compileFeature } from "./compile.js";
 export async function compileFiles(pattern) {
     var _a;
@@ -17,29 +15,17 @@ export async function compileFiles(pattern) {
     }
     console.log(`Compiled ${compiled.length} file${compiled.length === 1 ? '' : 's'}.`);
     const features = compiled.filter((f) => f !== undefined);
-    const generated = features.filter((f) => f.phrasesFileAction === 'generated');
-    if (generated.length) {
-        console.log(`Generated ${generated.length} phrases file${generated.length === 1 ? '' : 's'}.`);
-    }
     return { fns, outFns: features.map((f) => f.outFile.name) };
 }
 export async function compileFile(fn) {
-    var _a;
     fn = resolve(fn);
     const src = preprocess(readFileSync(fn, 'utf8').toString());
     try {
-        const { outFile, phrasesFile } = compileFeature(fn, src);
+        const { outFile } = compileFeature(fn, src);
         writeFileSync(outFile.name, outFile.value);
-        let phrasesFileAction = 'ignored';
-        if (!existsSync(phrasesFile.name)) {
-            phrasesFileAction = 'generated';
-            writeFileSync(phrasesFile.name, phrasesFile.value);
-        }
-        return { phrasesFileAction, outFile, phrasesFile };
+        return { outFile };
     }
     catch (e) {
-        const outFileName = testFileName(fn);
-        writeFileSync(outFileName, VitestGenerator.error((_a = e.message) !== null && _a !== void 0 ? _a : `${e}`, e.stack));
         return undefined;
     }
 }

package/model/model.d.ts

@@ -14,6 +14,14 @@ export interface CodeGenerator {
     codeLiteral(src: string): string;
     stringParamDeclaration(index: number): string;
     variantParamDeclaration(index: number): string;
+    phraseMethods: PhraseMethod[];
+}
+export interface PhraseMethod {
+    name: string;
+    parameters: {
+        name: string;
+        type: string;
+    }[];
 }
 export interface Location {
     line: number;

package/package.json

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

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/vitest/index.d.ts

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

package/vitest/index.js

@@ -1,7 +1,13 @@
+import { readFile, writeFile } from 'fs/promises';
 import c from 'tinyrainbow';
 import { compileFeature } from "../compiler/compile.js";
 import { preprocess } from "../compiler/compiler.js";
-export default function harmonyPlugin({} = {}) {
+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) {
@@ -9,11 +15,14 @@ export default function harmonyPlugin({} = {}) {
                 return id;
             }
         },
-        transform(code, id, options) {
+        transform(code, id) {
             if (!id.endsWith('.harmony'))
                 return null;
             code = preprocess(code);
-            const { outFile } = compileFeature(id, code);
+            const { outFile, phraseMethods, featureClassName } = compileFeature(id, code, opts);
+            if (options.autoEditPhrases) {
+                void updatePhrasesFile(id, phraseMethods, featureClassName);
+            }
             return {
                 code: outFile.valueWithoutSourceMap,
                 map: outFile.sourceMap,
@@ -29,16 +38,6 @@ export default function harmonyPlugin({} = {}) {
             }
             config.test.reporters.splice(0, 0, new HarmonyReporter());
         },
-        // This has been removed in favor of using transform, so no need to generate an actual file
-        // async configureServer(server) {
-        //   const isWatchMode = server.config.server.watch !== null
-        //   const patterns = [`${watchDir}/**/*.harmony`]
-        //   if (isWatchMode) {
-        //     await watchFiles(patterns)
-        //   } else {
-        //     await compileFiles(patterns)
-        //   }
-        // },
     };
 }
 class HarmonyReporter {
@@ -82,3 +81,21 @@ function addPhrases(task, depth = 2) {
         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);
+    }
+}