harmonyc 0.1.0

package/Router.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Routers = exports.Router = void 0;
+const xmur3_1 = require("./util/xmur3");
+class Router {
+    constructor(outs, seed = 'TODO') {
+        this.outs = outs;
+        this.index = 0;
+        this.started = new Set();
+        this.covered = new Set();
+        this.random = (0, xmur3_1.xmur3)(seed);
+    }
+    next() {
+        if (this.outs.length === 0)
+            throw new Error('internal error: no outs');
+        if (this.index < this.outs.length)
+            return this.outs[this.index++];
+        else
+            return this.outs[this.random() % this.outs.length];
+    }
+    get incompleteCount() {
+        return this.outs.length - this.index;
+    }
+}
+exports.Router = Router;
+class Routers {
+    constructor(root) {
+        this.root = root;
+        this.routers = new Map();
+        this.discover(root);
+    }
+    discover(branch) {
+        const successors = branch.successors;
+        if (!this.routers.has(branch)) {
+            this.routers.set(branch, new Router(successors));
+        }
+        for (const s of successors)
+            this.discover(s);
+    }
+    get(branch) {
+        if (!this.routers.has(branch)) {
+            this.routers.set(branch, new Router(branch.successors));
+        }
+        return this.routers.get(branch);
+    }
+    nextWalk() {
+        const walk = [];
+        let current = this.root;
+        while (current.successors.length) {
+            current = this.get(current).next();
+            walk.push(current);
+        }
+        return walk;
+    }
+    getIncompleteCount() {
+        return Array.from(this.routers.values()).reduce((sum, r) => sum + r.incompleteCount, 0);
+    }
+}
+exports.Routers = Routers;

package/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compiler_1 = require("./compiler");
+if (process.argv.length < 3) {
+    console.error("Usage: harmonyc <input files glob pattern>");
+    process.exit(1);
+}
+const args = process.argv.slice(2);
+void (0, compiler_1.compileFiles)(args);

package/compile.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFeature = void 0;
+const indent_1 = require("./util/indent");
+const model_1 = require("./model");
+const parser_1 = require("./parser");
+function compileFeature(name, src) {
+    const root = (0, parser_1.parse)(src);
+    const tests = (0, model_1.makeTests)(root);
+    const lines = [
+        `Feature: ${name}`,
+        '',
+        ...(0, indent_1.indent)(tests.flatMap((test) => test.toGherkin())),
+    ];
+    lines[0] = `Feature: ${name}`;
+    return lines.join('\n');
+}
+exports.compileFeature = compileFeature;

package/compiler.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFile = exports.compileFiles = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const compile_1 = require("./compile");
+function compileFiles(pattern) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fns = yield (0, fast_glob_1.default)(pattern);
+        if (!fns.length)
+            throw new Error(`No files found for pattern: ${String(pattern)}`);
+        yield Promise.all(fns.map((fn) => compileFile(fn)));
+    });
+}
+exports.compileFiles = compileFiles;
+function compileFile(fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const src = (0, fs_1.readFileSync)(fn, 'utf8').toString();
+        const name = (0, path_1.basename)(fn).replace(/\.[a-z]+$/i, '');
+        const outFn = fn.replace(/\.[a-z]+$/i, '.feature');
+        (0, fs_1.writeFileSync)(outFn, (0, compile_1.compileFeature)(name, src));
+    });
+}
+exports.compileFile = compileFile;

package/lexer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexer = exports.T = void 0;
+const typescript_parsec_1 = require("typescript-parsec");
+var T;
+(function (T) {
+    T[T["Newline"] = 0] = "Newline";
+    T[T["EOF"] = 1] = "EOF";
+    T[T["Comment"] = 2] = "Comment";
+    T[T["Dent"] = 3] = "Dent";
+    T[T["Seq"] = 4] = "Seq";
+    T[T["Fork"] = 5] = "Fork";
+    T[T["State"] = 6] = "State";
+    T[T["Label"] = 7] = "Label";
+    T[T["ResponseMark"] = 8] = "ResponseMark";
+    T[T["Phrase"] = 9] = "Phrase";
+    T[T["Space"] = 10] = "Space";
+})(T || (exports.T = T = {}));
+exports.lexer = (0, typescript_parsec_1.buildLexer)([
+    [false, /^\s*\n/g, T.Newline],
+    [false, /^\s*$/g, T.EOF],
+    [false, /^#.*?(?=\n|$)/g, T.Comment],
+    [false, /^\/\/.*?(?=\n|$)/g, T.Comment],
+    [true, /^ {2}/g, T.Dent],
+    [true, /^- /g, T.Seq],
+    [true, /^\+ /g, T.Fork],
+    [true, /^\[\s*.*?\s*\]/g, T.State],
+    [true, /^[^-+\s[][^\n[]*?\s*:(?=\s*(?:\n|$))/g, T.Label],
+    [true, /^\s*=>\s*/g, T.ResponseMark],
+    [true, /^[^-+\s[][^\n[]*?(?=\s*(?:\n|$|\[|=>))/g, T.Phrase],
+]);

package/model.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Test = exports.makeTests = exports.Precondition = exports.Response = exports.Action = exports.Phrase = exports.Section = exports.Label = exports.State = exports.Step = exports.Branch = void 0;
+const Router_1 = require("./Router");
+const indent_1 = require("./util/indent");
+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;
+    }
+    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;
+    }
+}
+exports.Branch = Branch;
+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];
+    }
+    toGherkin() {
+        return this.phrases.flatMap((phrase) => phrase.toGherkin());
+    }
+}
+exports.Step = Step;
+class State {
+    constructor(text = '') {
+        this.text = text;
+    }
+}
+exports.State = State;
+class Label {
+    constructor(text = '') {
+        this.text = text;
+    }
+}
+exports.Label = Label;
+class Section extends Branch {
+    constructor(label = '', children, isFork = false) {
+        super(children);
+        this.label = new Label(label);
+        this.isFork = isFork;
+    }
+}
+exports.Section = Section;
+class Phrase {
+    constructor(text = '') {
+        this.text = text;
+    }
+    toGherkin() {
+        return [`${this.kind === 'action' ? 'When' : 'Then'} ${this.text}`];
+    }
+}
+exports.Phrase = Phrase;
+class Action extends Phrase {
+    constructor() {
+        super(...arguments);
+        this.kind = 'action';
+    }
+}
+exports.Action = Action;
+class Response extends Phrase {
+    constructor() {
+        super(...arguments);
+        this.kind = 'response';
+    }
+}
+exports.Response = Response;
+class Precondition extends Branch {
+    constructor(state = '') {
+        super();
+        this.state = new State();
+        this.state.text = state;
+    }
+}
+exports.Precondition = Precondition;
+function makeTests(root) {
+    const routers = new Router_1.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;
+}
+exports.makeTests = makeTests;
+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);
+    }
+    toGherkin() {
+        return [
+            `Scenario: ${this.testNumber}${this.labels.length > 0 ? ' - ' : ''}${this.labels.join(' - ')}`,
+            ...(0, indent_1.indent)(this.steps.flatMap((b) => b.toGherkin())),
+            '',
+        ];
+    }
+}
+exports.Test = Test;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "harmonyc",
+  "description": "Harmony Code - Test design compiler from high-level model to Gherkin",
+  "version": "0.1.0",
+  "author": "Bernát Kalló",
+  "bin": {
+    "harmonyc": "./cli.js"
+  },
+  "homepage": "https://github.com/harmony-ac/code#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harmony-ac/code.git"
+  },
+  "bugs": {
+    "url": "https://github.com/harmony-ac/code/issues"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.2",
+    "typescript-parsec": "0.3.4"
+  },
+  "license": "MIT",
+  "keywords": [
+    "unit test", "unit testing", "cucumber", "bdd", "behavior-driven",
+    "test design", "test design automation", "gherkin", "cucumber",
+    "specflow", "harmony.ac", "test framework", "model-based test",
+    "model-based testing", "test model", "test modeling", "test modelling"
+  ]
+}

package/parser.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const typescript_parsec_1 = require("typescript-parsec");
+const lexer_1 = require("./lexer");
+const model_1 = require("./model");
+function parse(input) {
+    const tokens = lexer_1.lexer.parse(input);
+    return (0, typescript_parsec_1.expectSingleResult)((0, typescript_parsec_1.expectEOF)(TEST_DESIGN.parse(tokens)));
+}
+exports.parse = parse;
+const PHRASE = (0, typescript_parsec_1.rule)();
+PHRASE.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.tok)(lexer_1.T.Phrase), ({ text }) => text));
+const STEP = (0, typescript_parsec_1.rule)();
+STEP.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.seq)(PHRASE, (0, typescript_parsec_1.rep_sc)((0, typescript_parsec_1.kright)((0, typescript_parsec_1.tok)(lexer_1.T.ResponseMark), PHRASE))), ([action, responses]) => new model_1.Step(action, responses).setFork(true)));
+const SECTION = (0, typescript_parsec_1.rule)();
+SECTION.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.tok)(lexer_1.T.Label), ({ text }) => new model_1.Section(text.slice(0, -1))));
+const BRANCH = (0, typescript_parsec_1.rule)();
+BRANCH.setPattern((0, typescript_parsec_1.alt_sc)(STEP, SECTION));
+const DENTS = (0, typescript_parsec_1.rule)();
+DENTS.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.opt_sc)((0, typescript_parsec_1.seq)((0, typescript_parsec_1.rep_sc)((0, typescript_parsec_1.tok)(lexer_1.T.Dent)), (0, typescript_parsec_1.alt_sc)((0, typescript_parsec_1.tok)(lexer_1.T.Seq), (0, typescript_parsec_1.tok)(lexer_1.T.Fork)))), (lineHead) => {
+    if (!lineHead)
+        return { dent: 0, isFork: true };
+    const [dents, seqOrFork] = lineHead;
+    return { dent: dents.length + 1, isFork: seqOrFork.kind === lexer_1.T.Fork };
+}));
+const LINE = (0, typescript_parsec_1.rule)();
+LINE.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.seq)(DENTS, BRANCH), ([{ dent, isFork }, branch], [start, end]) => ({
+    dent,
+    branch: branch.setFork(isFork),
+})));
+const TEST_DESIGN = (0, typescript_parsec_1.rule)();
+TEST_DESIGN.setPattern((0, typescript_parsec_1.apply)((0, typescript_parsec_1.rep_sc)(LINE), (lines) => {
+    const startDent = 0;
+    let dent = startDent;
+    const root = new model_1.Section();
+    let parent = root;
+    let lineNo = 0;
+    for (const { dent: d, branch } of lines) {
+        ++lineNo;
+        if (d > dent + 1) {
+            throw new Error(`invalid indent ${d} at line ${lineNo}`);
+        }
+        else if (d === dent + 1) {
+            parent = parent.children[parent.children.length - 1];
+            ++dent;
+        }
+        else if (d < startDent) {
+            throw new Error(`invalid indent at line ${lineNo}`);
+        }
+        else
+            while (d < dent) {
+                parent = parent.parent;
+                --dent;
+            }
+        parent.addChild(branch);
+    }
+    return root;
+}));
+function inputText(start, end) {
+    let text = '';
+    let t = start;
+    while (t && t !== end) {
+        text += t.text;
+        t = t.next;
+    }
+    return text;
+}

package/util/indent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indent = void 0;
+function indent(lines) {
+    return lines.map((line) => `    ${line}`);
+}
+exports.indent = indent;

package/util/xmur3.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xmur3 = void 0;
+// https://stackoverflow.com/a/47593316
+function xmur3(str) {
+    let h = 1779033703 ^ str.length;
+    for (let i = 0; i < str.length; i++)
+        (h = Math.imul(h ^ str.charCodeAt(i), 3432918353)),
+            (h = (h << 13) | (h >>> 19));
+    return function () {
+        h = Math.imul(h ^ (h >>> 16), 2246822507);
+        h = Math.imul(h ^ (h >>> 13), 3266489909);
+        return (h ^= h >>> 16) >>> 0;
+    };
+}
+exports.xmur3 = xmur3;