harmonyc 0.6.0-8 → 0.7.0

package/js_api/js_api.js

@@ -1,83 +0,0 @@
-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_actions, _FeatureContext_responses, _FeatureContext_parameterTypeRegistry;
-import { CucumberExpression, ParameterTypeRegistry, } from '@cucumber/cucumber-expressions';
-class Definition {
-    constructor(expr, fn) {
-        this.expr = expr;
-        this.fn = fn;
-    }
-}
-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 (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);
-                return;
-            }
-            // call the action
-            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(`Action not defined: ${s}`);
-            }
-            if (matching.length > 1) {
-                throw new Error(`Ambiguous: ${s}\n${matching
-                    .map((i) => __classPrivateFieldGet(this, _FeatureContext_actions, "f")[i].expr.source)
-                    .join('\n')}`);
-            }
-            const match = matches[matching[0]];
-            const def = __classPrivateFieldGet(this, _FeatureContext_actions, "f")[matching[0]];
-            const docstring = fn;
-            return Promise.resolve(def.fn(...match.map((m) => m.getValue(undefined)), docstring));
-        });
-        this.Response = ((s, 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);
-                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(`Response 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]];
-            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) {
-    if (!fn) {
-        // 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 {
-        // (re)define the feature
-        featureDefs.set(s, fn);
-    }
-}

package/languages/Gherkin.js

@@ -1,33 +0,0 @@
-export class Gherkin {
-    constructor(outFile) {
-        this.outFile = outFile;
-    }
-    feature(feature) {
-        this.outFile.print(`Feature: ${feature.name}`);
-        this.outFile.print('');
-        this.outFile.indent(() => {
-            for (const test of feature.tests) {
-                test.toCode(this);
-            }
-        });
-    }
-    test(t) {
-        this.outFile.print(`Scenario: ${t.name}`);
-        this.outFile.indent(() => {
-            for (const step of t.steps) {
-                step.toCode(this);
-            }
-        });
-        this.outFile.print('');
-    }
-    phrase(p) {
-        this.outFile.print(`${p.keyword} ${p.text} || ${p.feature}`);
-        if (p.docstring !== undefined) {
-            this.outFile.indent(() => {
-                this.outFile.print(`"""`);
-                this.outFile.print(...p.docstring.split('\n'));
-                this.outFile.print(`"""`);
-            });
-        }
-    }
-}

package/languages/JavaScript.js

@@ -1,87 +0,0 @@
-import { basename } from 'path';
-export class NodeTest {
-    constructor(tf, sf) {
-        this.tf = tf;
-        this.sf = sf;
-        this.framework = 'vitest';
-        this.phrases = [];
-    }
-    feature(feature) {
-        const stepsModule = './' + basename(this.sf.name.replace(/.(js|ts)$/, ''));
-        this.phrases = [];
-        if (this.framework === 'vitest') {
-            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(${str(feature.name)}, ({ Action, Response }) => {`);
-        this.sf.indent(() => {
-            for (const phrase of this.phrases) {
-                this.sf.print(`${capitalize(phrase.kind)}(${str(phrase.text)}, () => {`);
-                this.sf.indent(() => {
-                    this.sf.print(`throw new Error(${str(`Pending: ${phrase.text}`)})`);
-                });
-                this.sf.print('})');
-            }
-        });
-        this.sf.print('})');
-    }
-    test(t) {
-        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.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;
-        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/model.js

@@ -1,216 +0,0 @@
-import { Routers } from './Router.js';
-export class Feature {
-    constructor(name) {
-        this.name = name;
-        this.root = new Section();
-        this.definitions = new Map();
-        this.prelude = '';
-    }
-    get tests() {
-        return makeTests(this.root);
-    }
-    toCode(cg) {
-        cg.feature(this);
-    }
-}
-export class Branch {
-    constructor(children = []) {
-        this.isFork = false;
-        this.isEnd = false;
-        this.children = children;
-        children.forEach((child) => (child.parent = this));
-    }
-    setFork(isFork) {
-        this.isFork = isFork;
-        return this;
-    }
-    setFeature(feature) {
-        for (const child of this.children)
-            child.setFeature(feature);
-        return this;
-    }
-    addChild(child, index = this.children.length) {
-        this.children.splice(index, 0, child);
-        child.parent = this;
-        return child;
-    }
-    get isLeaf() {
-        return this.children.length === 0;
-    }
-    get successors() {
-        if (!this.isLeaf)
-            return this.children.filter((c, i) => i === 0 || c.isFork);
-        else {
-            if (this.isEnd)
-                return [];
-            const next = this.nextNonForkAncestorSibling;
-            if (next)
-                return [next];
-            return [];
-        }
-    }
-    get nextNonForkAncestorSibling() {
-        if (!this.parent)
-            return undefined;
-        const { nextSibling } = this;
-        if (nextSibling && !nextSibling.isFork)
-            return nextSibling;
-        return this.parent.nextNonForkAncestorSibling;
-    }
-    get nextSibling() {
-        if (!this.parent)
-            return undefined;
-        return this.parent.children[this.siblingIndex + 1];
-    }
-    get siblingIndex() {
-        var _a, _b;
-        return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.indexOf(this)) !== null && _b !== void 0 ? _b : -1;
-    }
-}
-export class Step extends Branch {
-    constructor(action = '', responses = [], children, isFork = false) {
-        super(children);
-        this.action = new Action(action);
-        this.responses = responses.map((response) => new Response(response));
-        this.isFork = isFork;
-    }
-    get phrases() {
-        return [this.action, ...this.responses];
-    }
-    toCode(cg) {
-        for (const phrase of this.phrases) {
-            phrase.toCode(cg);
-        }
-    }
-    setFeature(feature) {
-        this.action.setFeature(feature);
-        for (const response of this.responses)
-            response.setFeature(feature);
-        return super.setFeature(feature);
-    }
-}
-export class State {
-    constructor(text = '') {
-        this.text = text;
-    }
-}
-export class Label {
-    constructor(text = '') {
-        this.text = text;
-    }
-}
-export class Section extends Branch {
-    constructor(label = '', children, isFork = false) {
-        super(children);
-        this.label = new Label(label);
-        this.isFork = isFork;
-    }
-}
-export class Phrase {
-    constructor(text = '') {
-        this.text = text;
-    }
-    setFeature(feature) {
-        this.feature = feature;
-    }
-    get keyword() {
-        return this.kind === 'action' ? 'When' : 'Then';
-    }
-    toCode(cg) {
-        return cg.phrase(this);
-    }
-    definition() {
-        const key = this.kind === 'action' ? this.text : `=> ${this.text}`;
-        let args;
-        let code;
-        for (const [ce, c] of this.feature.definitions.entries()) {
-            const m = ce.match(key);
-            if (!m)
-                continue;
-            if (args !== undefined)
-                throw new Error(`Ambiguous definition: ${key}`);
-            args = m;
-            code = c;
-        }
-        if (args === undefined)
-            return undefined;
-        return code.replace(/\$([$_1-9])/g, (s, varName) => {
-            var _a;
-            if (varName.match(/[1-9]/))
-                return JSON.stringify(args[parseInt(varName) - 1].getValue(undefined));
-            else if (varName === '_')
-                return JSON.stringify((_a = this.docstring) !== null && _a !== void 0 ? _a : '');
-            else if (varName === '$')
-                return '$';
-            else
-                return s;
-        });
-    }
-}
-export class Action extends Phrase {
-    constructor() {
-        super(...arguments);
-        this.kind = 'action';
-    }
-}
-export class Response extends Phrase {
-    constructor() {
-        super(...arguments);
-        this.kind = 'response';
-    }
-}
-export class Precondition extends Branch {
-    constructor(state = '') {
-        super();
-        this.state = new State();
-        this.state.text = state;
-    }
-}
-export function makeTests(root) {
-    const routers = new Routers(root);
-    const tests = [];
-    let ic = routers.getIncompleteCount();
-    let newIc;
-    do {
-        const newTest = new Test(root, routers.nextWalk());
-        newIc = routers.getIncompleteCount();
-        if (newIc < ic)
-            tests.push(newTest);
-        ic = newIc;
-    } while (ic > 0);
-    // sort by order of appearance of the last branch
-    const branchIndex = new Map();
-    let i = 0;
-    function walk(branch) {
-        branchIndex.set(branch, i++);
-        for (const child of branch.children)
-            walk(child);
-    }
-    walk(root);
-    tests.sort((a, b) => branchIndex.get(a.last) - branchIndex.get(b.last));
-    tests.forEach((test, i) => (test.testNumber = `T${i + 1}`));
-    return tests;
-}
-export class Test {
-    constructor(root, branches) {
-        this.root = root;
-        this.branches = branches;
-    }
-    get steps() {
-        return this.branches.filter((b) => b instanceof Step);
-    }
-    get last() {
-        return this.steps[this.steps.length - 1];
-    }
-    get labels() {
-        return this.branches
-            .filter((b) => b instanceof Section)
-            .map((s) => s.label.text);
-    }
-    get name() {
-        return `${this.testNumber}${this.labels.length > 0 ? ' - ' : ''}${this.labels.join(' - ')}`;
-    }
-    toCode(cg) {
-        cg.test(this);
-    }
-}

package/syntax.js

@@ -1,102 +0,0 @@
-import remarkParse from 'remark-parse';
-import { unified } from 'unified';
-import { Feature, Section, Step } from './model.js';
-export function parse({ fileName, src, }) {
-    const tree = unified().use(remarkParse).parse(src);
-    const rootNodes = tree.children;
-    const feature = new Feature('');
-    const headings = [feature.root];
-    let name;
-    for (let i = 0; i < rootNodes.length; i++) {
-        const node = rootNodes[i];
-        if (node.type === 'heading') {
-            if (node.depth === 1 && name === undefined) {
-                name = textContent(node);
-            }
-            const level = node.depth;
-            const section = new Section(textContent(node), [], true);
-            setLocation(section, node, fileName);
-            const last = headings.slice(0, level).reverse().find(Boolean);
-            last.addChild(section);
-            headings[level] = section;
-            headings.length = level + 1;
-        }
-        else {
-            const last = headings[headings.length - 1];
-            for (const branch of topLevel(node))
-                last.addChild(branch);
-        }
-    }
-    feature.name = name !== null && name !== void 0 ? name : fileName;
-    feature.root.setFeature(feature);
-    return feature;
-    function topLevel(node) {
-        if (node.type === 'paragraph')
-            return [];
-        if (node.type == 'list')
-            return list(node);
-        return [];
-    }
-    function list(node) {
-        const isFork = node.ordered === false;
-        return node.children.map((item) => listItem(item, isFork));
-    }
-    function listItem(node, isFork) {
-        const first = node.children[0];
-        const text = textContent(first);
-        let branch;
-        if (first.type === 'heading') {
-            branch = new Section(text, [], isFork);
-        }
-        else {
-            const [action, ...responses] = text.split(/(?:^| )=>(?: |$)/);
-            const step = (branch = new Step(action, responses.filter(Boolean), [], isFork));
-            setLocation(step.action, first, fileName);
-            for (const response of step.responses) {
-                // todo separate locations along =>'s
-                setLocation(response, first, fileName);
-            }
-            let i = 0;
-            for (const child of node.children.slice(1)) {
-                if (child.type === 'list')
-                    break;
-                if (child.type === 'code') {
-                    if (step.phrases[i])
-                        step.phrases[i].docstring = child.value;
-                    else
-                        break;
-                    ++i;
-                }
-            }
-        }
-        for (const child of node.children) {
-            if (child.type === 'list') {
-                for (const b of list(child))
-                    branch.addChild(b);
-            }
-        }
-        setLocation(branch, node, fileName);
-        return branch;
-    }
-}
-function textContent(node) {
-    if (!node)
-        return '';
-    if (node.type === 'text') {
-        return node.value.split(/\s+/).filter(Boolean).join(' ');
-    }
-    if (node.type === 'list')
-        return '';
-    if (!('children' in node))
-        return '';
-    return node.children.map(textContent).filter(Boolean).join(' ');
-}
-function setLocation(model, node, fileName) {
-    if (!node.position)
-        return;
-    model.location = {
-        line: node.position.start.line,
-        column: node.position.start.column,
-        fileName,
-    };
-}

package/watch.js

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