harmonyc 0.6.0-6 → 0.6.0-8

package/compile.js

@@ -4,11 +4,11 @@ import { parse } from './syntax.js';
 import { stepsFileName, testFileName } from './filenames/filenames.js';
 export function compileFeature(fileName, src) {
     const feature = parse({ fileName, src });
-    const outFn = testFileName(fileName);
-    const outFile = new OutFile(outFn);
+    const testFn = testFileName(fileName);
+    const testFile = new OutFile(testFn);
     const stepsFn = stepsFileName(fileName);
     const stepsFile = new OutFile(stepsFn);
-    const cg = new NodeTest(outFile, stepsFile);
+    const cg = new NodeTest(testFile, stepsFile);
     feature.toCode(cg);
-    return { outFile, stepsFile };
+    return { outFile: testFile, stepsFile };
 }

package/compiler.js

@@ -5,16 +5,22 @@ export async function compileFiles(pattern) {
     const fns = await glob(pattern);
     if (!fns.length)
         throw new Error(`No files found for pattern: ${String(pattern)}`);
-    const outFns = await Promise.all(fns.map((fn) => compileFile(fn)));
+    const features = await Promise.all(fns.map((fn) => compileFile(fn)));
     console.log(`Compiled ${fns.length} file${fns.length === 1 ? '' : 's'}.`);
-    return { fns, outFns };
+    const generated = features.filter((f) => f.stepsFileAction === 'generated');
+    if (generated.length) {
+        console.log(`Generated ${generated.length} steps file${generated.length === 1 ? '' : 's'}.`);
+    }
+    return { fns, outFns: features.map((f) => f.outFile.name) };
 }
 export async function compileFile(fn) {
     const src = readFileSync(fn, 'utf8').toString();
     const { outFile, stepsFile } = compileFeature(fn, src);
     writeFileSync(outFile.name, outFile.value);
+    let stepsFileAction = 'ignored';
     if (!existsSync(stepsFile.name)) {
+        stepsFileAction = 'generated';
         writeFileSync(stepsFile.name, stepsFile.value);
     }
-    return outFile.name;
+    return { stepsFileAction, outFile, stepsFile };
 }

package/filenames/filenames.js

@@ -1,5 +1,5 @@
 import glob from 'fast-glob';
-const { globSync } = glob;
+const { globSync, convertPathToPattern } = glob;
 export function base(fn) {
     return fn.replace(/\.harmony\.md$/i, '');
 }
@@ -7,9 +7,11 @@ export function testFileName(fn) {
     return base(fn) + '.test.mjs';
 }
 export function stepsFileName(fn) {
-    const existing = globSync(base(fn) + '.steps.*');
+    const baseFn = base(fn);
+    const pattern = convertPathToPattern(baseFn);
+    const existing = globSync(`${pattern}.steps.*`);
     if (existing.length) {
         return existing.sort()[0];
     }
-    return base(fn) + '.steps.ts';
+    return `${baseFn}.steps.ts`;
 }

package/js_api/js_api.js

@@ -11,14 +11,14 @@ class Definition {
         this.fn = fn;
     }
 }
-const features = new Map();
+const featureDefs = new Map();
 class FeatureContext {
     constructor() {
         _FeatureContext_actions.set(this, []);
         _FeatureContext_responses.set(this, []);
         _FeatureContext_parameterTypeRegistry.set(this, new ParameterTypeRegistry());
         this.Action = ((s, fn) => {
-            if (fn) {
+            if (typeof fn === 'function') {
                 const expr = new CucumberExpression(s, __classPrivateFieldGet(this, _FeatureContext_parameterTypeRegistry, "f"));
                 const def = new Definition(expr, fn);
                 __classPrivateFieldGet(this, _FeatureContext_actions, "f").push(def);
@@ -37,10 +37,11 @@ class FeatureContext {
             }
             const match = matches[matching[0]];
             const def = __classPrivateFieldGet(this, _FeatureContext_actions, "f")[matching[0]];
-            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined))));
+            const docstring = fn;
+            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined)), docstring));
         });
         this.Response = ((s, fn) => {
-            if (fn) {
+            if (typeof fn === 'function') {
                 const expr = new CucumberExpression(s, __classPrivateFieldGet(this, _FeatureContext_parameterTypeRegistry, "f"));
                 const def = new Definition(expr, fn);
                 __classPrivateFieldGet(this, _FeatureContext_responses, "f").push(def);
@@ -59,23 +60,24 @@ class FeatureContext {
             }
             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))));
+            const docstring = fn;
+            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined)), docstring));
         });
     }
 }
 _FeatureContext_actions = new WeakMap(), _FeatureContext_responses = new WeakMap(), _FeatureContext_parameterTypeRegistry = new WeakMap();
 export function Feature(s, fn) {
-    let ctx;
     if (!fn) {
-        ctx = features.get(s);
-        if (!ctx)
+        // instantiate the feature
+        const fn = featureDefs.get(s);
+        if (!fn)
             throw new Error(`Feature not found: ${s}`);
+        const ctx = new FeatureContext();
+        fn(ctx);
+        return ctx;
     }
     else {
-        // redefine the feature
-        ctx = new FeatureContext();
-        features.set(s, ctx);
+        // (re)define the feature
+        featureDefs.set(s, fn);
     }
-    fn === null || fn === void 0 ? void 0 : fn(ctx);
-    return ctx;
 }

package/languages/JavaScript.js

@@ -1,7 +1,7 @@
 import { basename } from 'path';
 export class NodeTest {
-    constructor(of, sf) {
-        this.of = of;
+    constructor(tf, sf) {
+        this.tf = tf;
         this.sf = sf;
         this.framework = 'vitest';
         this.phrases = [];
@@ -10,21 +10,21 @@ export class NodeTest {
         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.tf.print(`import { test, expect } from 'vitest';`);
+            this.tf.print(`import { Feature } from 'harmonyc/test';`);
+            this.tf.print(`import ${str(stepsModule)};`);
         }
         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.print(`Feature(${str(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.print(`${capitalize(phrase.kind)}(${str(phrase.text)}, () => {`);
                 this.sf.indent(() => {
-                    this.sf.print(`throw new Error(${JSON.stringify(`Pending: ${phrase.text}`)})`);
+                    this.sf.print(`throw new Error(${str(`Pending: ${phrase.text}`)})`);
                 });
                 this.sf.print('})');
             }
@@ -32,22 +32,56 @@ export class NodeTest {
         this.sf.print('})');
     }
     test(t) {
-        this.of.print(`test('${t.name}', async (context) => {`);
-        this.of.indent(() => {
+        this.featureVars = new Map();
+        this.tf.print(`test('${t.name}', async (context) => {`);
+        this.tf.indent(() => {
             for (const step of t.steps) {
                 step.toCode(this);
             }
         });
-        this.of.print('})');
-        this.of.print('');
+        this.tf.print('})');
+        this.tf.print('');
     }
     phrase(p) {
         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)})`);
+        let f = this.featureVars.get(feature);
+        if (!f) {
+            f = toId(feature, this.featureVars);
+            this.tf.print(`const ${f} = Feature(${str(feature)})`);
+        }
+        const docstring = p.docstring ? ', \n' + templateStr(p.docstring) : '';
+        this.tf.print(`await ${f}.${capitalize(p.kind)}(${str(p.text)}${docstring})`);
     }
 }
+function str(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, previous) {
+    if (previous.has(s))
+        return previous.get(s);
+    let base = pascalCase(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 pascalCase(s) {
+    return s
+        .split(/[^a-zA-Z0-9]/)
+        .map(capitalize)
+        .join('');
+}

package/outFile.js

@@ -40,7 +40,10 @@ export class OutFile {
         return this;
     }
     get value() {
-        return (this.lines.join('\n') +
-            `\n\n//# sourceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`);
+        let res = this.lines.join('\n');
+        if (this.currentLoc) {
+            res += `\n\n//# sourceMappingURL=data:application/json,${encodeURIComponent(this.sm.toString())}`;
+        }
+        return res;
     }
 }

package/package.json

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

package/run.js

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

package/syntax.js

@@ -1,7 +1,6 @@
 import remarkParse from 'remark-parse';
 import { unified } from 'unified';
 import { Feature, Section, Step } from './model.js';
-import { definitions } from './definitions.js';
 export function parse({ fileName, src, }) {
     const tree = unified().use(remarkParse).parse(src);
     const rootNodes = tree.children;
@@ -36,23 +35,12 @@ export function parse({ fileName, src, }) {
             return [];
         if (node.type == 'list')
             return list(node);
-        if (node.type === 'code')
-            return code(node);
         return [];
     }
     function list(node) {
         const isFork = node.ordered === false;
         return node.children.map((item) => listItem(item, isFork));
     }
-    function code(node) {
-        var _a;
-        if (!((_a = node.meta) === null || _a === void 0 ? void 0 : _a.match(/harmony/)))
-            return [];
-        const code = node.value;
-        const marker = '///';
-        definitions({ marker, code, feature });
-        return [];
-    }
     function listItem(node, isFork) {
         const first = node.children[0];
         const text = textContent(first);

package/definitions.js

@@ -1,22 +0,0 @@
-import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
-const registry = new ParameterTypeRegistry();
-export function definitions({ marker, code, feature, }) {
-    var _a, _b;
-    const re = new RegExp(`^\s*${q(marker)}(.*?)$`, 'gm');
-    let match = re.exec(code);
-    const start = (_a = match === null || match === void 0 ? void 0 : match.index) !== null && _a !== void 0 ? _a : code.length;
-    feature.prelude += code.slice(0, start);
-    while (match) {
-        const bodyStart = match.index + match[0].length;
-        const head = match[1].trim();
-        match = re.exec(code);
-        const end = (_b = match === null || match === void 0 ? void 0 : match.index) !== null && _b !== void 0 ? _b : code.length;
-        const body = code.slice(bodyStart, end).trim();
-        if (body) {
-            feature.definitions.set(new CucumberExpression(head, registry), body);
-        }
-    }
-}
-function q(pattern) {
-    return pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}