harmonyc 0.4.3 → 0.6.0-0

package/README.md

@@ -6,18 +6,35 @@ A test design & BDD tool that helps you separate the _what_ to test from the _ho
 
 ## Usage
 
-1. Have Node.js installed.
-2. You can compile your `*.md` files in the `src` folder by running
+- ### watch and run mode
 
-   ```bash script
-   npx harmonyc src/**/*.md
-   ```
+  - You can compile and run your `*.md` files in the `src` folder, and watch it, by running
 
-3. Then you can run the generated tests with Vitest by running
+    ```bash script
+    npx harmonyc --run --watch src/**/*.md
+    ```
 
-   ```bash script
-   npx vitest
-   ```
+- ### compiling and running
+
+  - You can compile and run your `*.md` files in the `src` folder by running
+
+    ```bash script
+    npx harmonyc --run src/**/*.md
+    ```
+
+- ### compiling and running separately
+
+  1.  You can compile your `*.md` files in the `src` folder by running
+
+      ```bash script
+      npx harmonyc src/**/*.md
+      ```
+
+  2.  Then you can run the generated tests with Vitest by running
+
+      ```bash script
+      npx vitest
+      ```
 
 ## Syntax
 

package/cli.js

@@ -2,10 +2,12 @@
 import { compileFiles } from './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' },
+        run: { type: 'boolean' },
     },
     allowPositionals: true,
 });
@@ -13,9 +15,18 @@ if (args.positionals.length === 0 || args.values.help) {
     console.error('Usage: harmonyc <input files glob pattern>');
     process.exit(1);
 }
-if (args.values.watch) {
-    void watchFiles(args.positionals);
-}
-else {
-    void compileFiles(args.positionals);
-}
+;
+(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/compile.js

@@ -3,8 +3,9 @@ import { OutFile } from './outFile.js';
 import { parse } from './syntax.js';
 export function compileFeature(fileName, src) {
     const feature = parse({ fileName, src });
-    const of = new OutFile();
+    const outFn = `${fileName.replace(/\.[a-z]+$/i, '')}.mjs`;
+    const of = new OutFile(outFn);
     const cg = new NodeTest(of);
     feature.toCode(cg);
-    return of.value;
+    return of;
 }

package/compiler.js

@@ -1,18 +1,17 @@
 import glob from 'fast-glob';
 import { readFileSync, writeFileSync } from 'fs';
-import { basename } from 'path';
 import { compileFeature } from './compile.js';
 export async function compileFiles(pattern) {
     const fns = await glob(pattern);
     if (!fns.length)
         throw new Error(`No files found for pattern: ${String(pattern)}`);
-    await Promise.all(fns.map((fn) => compileFile(fn)));
+    const outFns = await Promise.all(fns.map((fn) => compileFile(fn)));
     console.log(`Compiled ${fns.length} file${fns.length === 1 ? '' : 's'}.`);
-    return fns;
+    return { fns, outFns };
 }
 export async function compileFile(fn) {
     const src = readFileSync(fn, 'utf8').toString();
-    const name = basename(fn).replace(/\.[a-z]+$/i, '');
-    const outFn = `${fn.replace(/\.[a-z]+$/i, '')}.mjs`;
-    writeFileSync(outFn, compileFeature(fn, src));
+    const outFile = compileFeature(fn, src);
+    writeFileSync(outFile.name, outFile.value);
+    return outFile.name;
 }

package/js_api/js_api.js

@@ -0,0 +1,59 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FeatureContext_defs, _FeatureContext_parameterTypeRegistry;
+import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
+class Definition {
+    constructor(expr, fn) {
+        this.expr = expr;
+        this.fn = fn;
+    }
+}
+const features = new Map();
+class FeatureContext {
+    constructor() {
+        _FeatureContext_defs.set(this, []);
+        _FeatureContext_parameterTypeRegistry.set(this, new ParameterTypeRegistry());
+        this.Action = ((s, fn) => {
+            if (fn) {
+                const expr = new CucumberExpression(s, __classPrivateFieldGet(this, _FeatureContext_parameterTypeRegistry, "f"));
+                const def = new Definition(expr, fn);
+                __classPrivateFieldGet(this, _FeatureContext_defs, "f").push(def);
+                return;
+            }
+            // call the action
+            const matches = __classPrivateFieldGet(this, _FeatureContext_defs, "f").map((def) => def.expr.match(s));
+            const matching = [...matches.keys()].filter((i) => matches[i]);
+            if (matching.length === 0) {
+                throw new Error(`Not defined: ${s}`);
+            }
+            if (matching.length > 1) {
+                throw new Error(`Ambiguous: ${s}\n${matching
+                    .map((i) => __classPrivateFieldGet(this, _FeatureContext_defs, "f")[i].expr.source)
+                    .join('\n')}`);
+            }
+            const match = matches[matching[0]];
+            const def = __classPrivateFieldGet(this, _FeatureContext_defs, "f")[matching[0]];
+            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined))));
+        });
+        this.Response = this.Action;
+    }
+}
+_FeatureContext_defs = new WeakMap(), _FeatureContext_parameterTypeRegistry = new WeakMap();
+export function Feature(s, fn) {
+    let ctx;
+    if (!fn) {
+        ctx = features.get(s);
+        if (!ctx)
+            throw new Error(`Feature not found: ${s}`);
+    }
+    else {
+        // redefine the feature
+        ctx = new FeatureContext();
+        features.set(s, ctx);
+    }
+    fn === null || fn === void 0 ? void 0 : fn(ctx);
+    return ctx;
+}

package/js_api/js_api.steps.js

@@ -0,0 +1,11 @@
+import { expect } from 'vitest';
+import { Feature } from 'harmonyc/test';
+Feature('js api', ({ Action, Response }) => {
+    let n = 0;
+    Action('add {int}', async function (k) {
+        n += k;
+    });
+    Response('result is {float}', async function (k) {
+        expect(n).toBe(k);
+    });
+});

package/languages/JavaScript.js

@@ -1,31 +1,41 @@
+import { basename } from 'path';
 export class NodeTest {
-    constructor(outFile) {
-        this.outFile = outFile;
+    constructor(of) {
+        this.of = of;
         this.framework = 'vitest';
+        this.phrases = [];
     }
     feature(feature) {
+        const stepsModule = './' +
+            basename(this.of.name.replace(/(\.(spec|test)s?)?\.[a-z]+$/i, '.steps'));
+        this.phrases = [];
         if (this.framework === 'vitest') {
-            this.outFile.print(`import { test, expect } from 'vitest';`);
+            this.of.print(`import { test, expect } from 'vitest';`);
+            this.of.print(`import { Feature } from 'harmonyc/test';`);
+            this.of.print(`import ${JSON.stringify(stepsModule)};`);
         }
-        this.outFile.print(feature.prelude);
+        this.of.print(feature.prelude);
         for (const test of feature.tests) {
             test.toCode(this);
         }
     }
     test(t) {
-        this.outFile.print(`test('${t.name}', async () => {`);
-        this.outFile.indent(() => {
+        this.of.print(`test('${t.name}', async (context) => {`);
+        this.of.indent(() => {
             for (const step of t.steps) {
                 step.toCode(this);
             }
         });
-        this.outFile.print('})');
-        this.outFile.print('');
+        this.of.print('})');
+        this.of.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'));
+        if (!this.phrases.some((x) => x.text === p.text))
+            this.phrases.push(p);
+        const feature = p.feature.name;
+        this.of.print(`await Feature(${JSON.stringify(feature)}).${capitalize(p.kind)}(${JSON.stringify(p.text)})`);
     }
 }
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/outFile.js

@@ -1,10 +1,11 @@
 import { SourceMapGenerator } from 'source-map-js';
 export class OutFile {
-    constructor(indentSpaces = 2) {
-        this.indentSpaces = indentSpaces;
+    constructor(name) {
+        this.name = name;
         this.lines = [];
         this.level = 0;
         this.sm = new SourceMapGenerator();
+        this.indentSpaces = 2;
     }
     indent(fn) {
         this.level++;

package/package.json

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

package/run.js

@@ -0,0 +1,24 @@
+import { exec } 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) {
+    var _a, _b;
+    const cmd = runWatchCommand(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);
+}

package/watch.js

@@ -1,10 +1,11 @@
 import { watch } from 'node:fs';
 import { compileFile, compileFiles } from './compiler.js';
 export async function watchFiles(patterns) {
-    const fns = await compileFiles(patterns);
+    const { fns, outFns } = await compileFiles(patterns);
     for (const file of fns) {
         watch(file, () => {
             compileFile(file);
         });
     }
+    return outFns;
 }