harmonyc 0.6.0-0 → 0.6.0-2

package/README.md

@@ -2,39 +2,18 @@
 
 A test design & BDD tool that helps you separate the _what_ to test from the _how_ to automate it. You write test cases in a simple Markdown format, and then automate them with Vitest (and soon with many more frameworks and languages).
 
-(**Note**: There have been big changes since v0.2.)
-
 ## Usage
 
 - ### watch and run mode
 
-  - You can compile and run your `*.md` files in the `src` folder, and watch it, by running
-
-    ```bash script
-    npx harmonyc --run --watch src/**/*.md
-    ```
-
-- ### compiling and running
-
-  - You can compile and run your `*.md` files in the `src` folder by running
+  - You can compile and run your `*.spec.md` files in the `src` folder, and watch it, by running
 
     ```bash script
-    npx harmonyc --run src/**/*.md
+    npx harmonyc --run --watch 'src/**/*.spec.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
-      ```
+    - => this will generate tests into `*.spec.mjs` files
+    - => this will create a stub `*.steps.ts` file if it doesn't exist
 
 ## Syntax
 

package/cli.js

@@ -6,8 +6,8 @@ import { run, runWatch } from './run.js';
 const args = parseArgs({
     options: {
         help: { type: 'boolean' },
-        watch: { type: 'boolean' },
-        run: { type: 'boolean' },
+        watch: { type: 'boolean', short: 'w' },
+        run: { type: 'boolean', short: 'r' },
     },
     allowPositionals: true,
 });

package/compile.js

@@ -4,8 +4,10 @@ import { parse } from './syntax.js';
 export function compileFeature(fileName, src) {
     const feature = parse({ fileName, src });
     const outFn = `${fileName.replace(/\.[a-z]+$/i, '')}.mjs`;
-    const of = new OutFile(outFn);
-    const cg = new NodeTest(of);
+    const outFile = new OutFile(outFn);
+    const stepsFn = outFn.replace(/(\.(spec|test)s?)?\.[a-z]+$/i, '.steps.ts');
+    const stepsFile = new OutFile(stepsFn);
+    const cg = new NodeTest(outFile, stepsFile);
     feature.toCode(cg);
-    return of;
+    return { outFile, stepsFile };
 }

package/compiler.js

@@ -1,5 +1,5 @@
 import glob from 'fast-glob';
-import { readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { compileFeature } from './compile.js';
 export async function compileFiles(pattern) {
     const fns = await glob(pattern);
@@ -11,7 +11,10 @@ export async function compileFiles(pattern) {
 }
 export async function compileFile(fn) {
     const src = readFileSync(fn, 'utf8').toString();
-    const outFile = compileFeature(fn, src);
+    const { outFile, stepsFile } = compileFeature(fn, src);
     writeFileSync(outFile.name, outFile.value);
+    if (!existsSync(stepsFile.name)) {
+        writeFileSync(stepsFile.name, stepsFile.value);
+    }
     return outFile.name;
 }

package/js_api/js_api.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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;
+var _FeatureContext_actions, _FeatureContext_responses, _FeatureContext_parameterTypeRegistry;
 import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
 class Definition {
     constructor(expr, fn) {
@@ -14,34 +14,56 @@ class Definition {
 const features = new Map();
 class FeatureContext {
     constructor() {
-        _FeatureContext_defs.set(this, []);
+        _FeatureContext_actions.set(this, []);
+        _FeatureContext_responses.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);
+                __classPrivateFieldGet(this, _FeatureContext_actions, "f").push(def);
                 return;
             }
             // call the action
-            const matches = __classPrivateFieldGet(this, _FeatureContext_defs, "f").map((def) => def.expr.match(s));
+            const matches = __classPrivateFieldGet(this, _FeatureContext_actions, "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)
+                    .map((i) => __classPrivateFieldGet(this, _FeatureContext_actions, "f")[i].expr.source)
                     .join('\n')}`);
             }
             const match = matches[matching[0]];
-            const def = __classPrivateFieldGet(this, _FeatureContext_defs, "f")[matching[0]];
+            const def = __classPrivateFieldGet(this, _FeatureContext_actions, "f")[matching[0]];
+            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined))));
+        });
+        this.Response = ((s, fn) => {
+            if (fn) {
+                const expr = new CucumberExpression(s, __classPrivateFieldGet(this, _FeatureContext_parameterTypeRegistry, "f"));
+                const def = new Definition(expr, fn);
+                __classPrivateFieldGet(this, _FeatureContext_responses, "f").push(def);
+                return;
+            }
+            // call the action
+            const matches = __classPrivateFieldGet(this, _FeatureContext_responses, "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_responses, "f")[i].expr.source)
+                    .join('\n')}`);
+            }
+            const match = matches[matching[0]];
+            const def = __classPrivateFieldGet(this, _FeatureContext_responses, "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();
+_FeatureContext_actions = new WeakMap(), _FeatureContext_responses = new WeakMap(), _FeatureContext_parameterTypeRegistry = new WeakMap();
 export function Feature(s, fn) {
     let ctx;
     if (!fn) {

package/languages/JavaScript.js

@@ -1,23 +1,35 @@
 import { basename } from 'path';
 export class NodeTest {
-    constructor(of) {
+    constructor(of, sf) {
         this.of = of;
+        this.sf = sf;
         this.framework = 'vitest';
         this.phrases = [];
     }
     feature(feature) {
-        const stepsModule = './' +
-            basename(this.of.name.replace(/(\.(spec|test)s?)?\.[a-z]+$/i, '.steps'));
+        const stepsModule = './' + basename(this.sf.name.replace(/.(js|ts)$/, ''));
         this.phrases = [];
         if (this.framework === '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.of.print(feature.prelude);
         for (const test of feature.tests) {
             test.toCode(this);
         }
+        this.sf.print(`import { Feature } from 'harmonyc/test';`);
+        this.sf.print('');
+        this.sf.print(`Feature(${JSON.stringify(feature.name)}, ({ Action, Response }) => {`);
+        this.sf.indent(() => {
+            for (const phrase of this.phrases) {
+                this.sf.print(`${capitalize(phrase.kind)}(${JSON.stringify(phrase.text)}, () => {`);
+                this.sf.indent(() => {
+                    this.sf.print(`throw new Error(${JSON.stringify(`Pending: ${phrase.text}`)})`);
+                });
+                this.sf.print('})');
+            }
+        });
+        this.sf.print('})');
     }
     test(t) {
         this.of.print(`test('${t.name}', async (context) => {`);

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "harmonyc",
   "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.6.0-0",
+  "version": "0.6.0-2",
   "author": "Bernát Kalló",
   "type": "module",
   "bin": {
     "harmonyc": "./cli.js"
   },
+  "exports": {
+    "./test": {
+      "types": "./test.d.ts",
+      "default": "./dist/js_api/js_api.js"
+    }
+  },
   "homepage": "https://github.com/harmony-ac/code#readme",
   "repository": {
     "type": "git",

package/test.d.ts

@@ -0,0 +1,7 @@
+type FeatureContext = {
+  Action(s: string): Promise<void>
+  Action(s: string, fn: Function): void
+  Response(s: string): Promise<void>
+  Response(s: string, fn: Function): void
+}
+export function Feature(name: string, fn: (ctx: FeatureContext) => void): void

package/js_api/js_api.steps.js

@@ -1,11 +0,0 @@
-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);
-    });
-});