@syndicate-lang/compiler - npm Package Compare versions

Comparing version 0.20.0 to 0.20.1

package.json

 {
   "name": "@syndicate-lang/compiler",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Syndicate/JS compiler library",
@@ -25,2 +25,6 @@ "homepage": "https://github.com/syndicate-lang/syndicate-js/tree/main/packages/compiler",
   },
+  "devDependencies": {
+    "@types/js-beautify": "1.14",
+    "js-beautify": "1.15"
+  },
   "main": "dist/syndicate-compiler.js",
@@ -30,3 +34,3 @@ "module": "lib/index.js",
   "author": "Tony Garnock-Jones <[e-mail]>",
-  "gitHead": "23dde452955d322b7581133fb6498135afebf948"
+  "gitHead": "502c0fd28668d57855edfaffb756d3c2b6d8c056"
 }

test/compiler.test.ts

@@ -7,2 +7,3 @@ /// SPDX-License-Identifier: GPL-3.0-or-later
 import './test-utils';
+import { js as format } from 'js-beautify';
 
@@ -28,116 +29,158 @@ type Error = { message: string, start: Pos | undefined, end: Pos | undefined };
 
+function expectCodeEqual(input: string, output: string) {
+    expect(format(translateNoErrors(input))).toBe(format(output));
+}
+
 describe('react', () => {
-    it('without label', () => {
-        expect(translateNoErrors(`react { a; b; c; }`)).toBe(
-            `__SYNDICATE__.Turn.active.facet(() => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;  a; b; c; });`);
-    });
-    it('with label', () => {
-        expect(translateNoErrors(`someLabel: react { a; b; c; }`)).toBe(
-            `__SYNDICATE__.Turn.active.facet(() => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; const someLabel = currentSyndicateFacet;  a; b; c; });`);
-    });
+
+    it('without label', () => expectCodeEqual(`react { a; b; c; }`, `
+__SYNDICATE__.Turn.active.facet(() => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  a; b; c;
+});`));
+
+    it('with label', () => expectCodeEqual(`someLabel: react { a; b; c; }`, `
+__SYNDICATE__.Turn.active.facet(() => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  const someLabel = currentSyndicateFacet;
+  a; b; c;
+});`));
+
 });
 
 describe('spawn', () => {
-    it('without name', () => {
-        expect(translateNoErrors(`spawn { a; b; c; }`)).toBe(
-            `__SYNDICATE__.Dataspace._spawn(() => { const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; a; b; c; });`);
-    });
-    it('with name', () => {
-        expect(translateNoErrors(`spawn named 'foo' { a; b; c; }`)).toBe(
-            `__SYNDICATE__.Dataspace._spawn(() => { const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; currentSyndicateFacet.actor.name = 'foo'; a; b; c; });`);
-    });
-    it('with missing name (known incorrect parsing and codegen)', () => {
-        // At present, the expr() parser accepts *empty input*. TODO: something better.
-        expect(translateNoErrors(`spawn named { a; b; c; }`)).toBe(
-            `__SYNDICATE__.Dataspace._spawn(() => { const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; currentSyndicateFacet.actor.name = ; a; b; c; });`);
-    });
+
+    it('without name', () => expectCodeEqual(`spawn { a; b; c; }`, `
+__SYNDICATE__.Dataspace._spawn(() => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  a; b; c;
+});`));
+
+    it('with name', () => expectCodeEqual(`spawn named 'foo' { a; b; c; }`, `
+__SYNDICATE__.Dataspace._spawn(() => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  currentSyndicateFacet.actor.name = 'foo';
+  a; b; c;
+});`));
+
+    // At present, the expr() parser accepts *empty input*. TODO: something better.
+    it('with missing name (known incorrect parsing and codegen)', () =>
+        expectCodeEqual(`spawn named { a; b; c; }`, `
+__SYNDICATE__.Dataspace._spawn(() => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  currentSyndicateFacet.actor.name = ;
+  a; b; c;
+});`));
+
 });
 
 describe('stop', () => {
-    it('non-statement', () => {
-        expect(translateNoErrors(`stop`)).toBe(
-            `stop`);
-    });
-    it('without facet, without body', () => {
-        expect(translateNoErrors(`stop;`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;});`);
-    });
-    it('without facet, empty body', () => {
-        expect(translateNoErrors(`stop {}`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;});`);
-    });
-    it('without facet, non-empty body', () => {
-        expect(translateNoErrors(`stop { a; b; }`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; a; b; });`);
-    });
-    it('with facet, without body', () => {
-        expect(translateNoErrors(`stop x.y;`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(x.y, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;});`);
-    });
-    it('with facet, empty body', () => {
-        expect(translateNoErrors(`stop x.y {}`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(x.y, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;});`);
-    });
-    it('with facet, non-empty body', () => {
-        expect(translateNoErrors(`stop x.y { a; b; }`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(x.y, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; a; b; });`);
-    });
-    it('nested stop, no labels', () => {
-        expect(translateNoErrors(`stop { stop; }`)).toBe(
-            `__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet; __SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;}); });`);
-    });
+
+    it('non-statement', () => expectCodeEqual(`stop`, `stop`));
+
+    it('without facet, without body', () => expectCodeEqual(`stop;`, `
+__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+});`));
+
+    it('without facet, empty body', () => expectCodeEqual(`stop {}`, `
+__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+});`));
+
+    it('without facet, non-empty body', () => expectCodeEqual(`stop { a; b; }`, `
+__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  a; b;
+});`));
+
+    it('with facet, without body', () => expectCodeEqual(`stop x.y;`, `
+__SYNDICATE__.Turn.active._stop(x.y, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+});`));
+
+    it('with facet, empty body', () => expectCodeEqual(`stop x.y {}`, `
+__SYNDICATE__.Turn.active._stop(x.y, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+});`));
+
+    it('with facet, non-empty body', () => expectCodeEqual(`stop x.y { a; b; }`, `
+__SYNDICATE__.Turn.active._stop(x.y, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  a; b;
+});`));
+
+    it('nested stop, no labels', () => expectCodeEqual(`stop { stop; }`, `
+__SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+  const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  __SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+    const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+  });
+});`));
+
 });
 
 describe('during', () => {
-    it('stop in body', () => {
-        expect(translateNoErrors(`during P => { a; stop; b; }`)).toBe(
-            `__SYNDICATE__.Turn.active.assertDataflow(() => ({ target: currentSyndicateTarget, assertion: __SYNDICATE__.Observe({
-            pattern: __SYNDICATE__.QuasiValue.finish((__SYNDICATE__.QuasiValue.lit(__SYNDICATE__.fromJS(P)))),
-            observer: __SYNDICATE__.Turn.ref(__SYNDICATE__.assertionFacetObserver(
-                (__vs) => {
-                    if (Array.isArray(__vs)) {
 
-                         a; __SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;}); b; 
-                    }
+    it('stop in body', () => expectCodeEqual(`during P => { a; stop; b; }`, `
+__SYNDICATE__.Turn.active.assertDataflow(() => ({
+    target: currentSyndicateTarget,
+    assertion: __SYNDICATE__.Observe({
+        pattern: __SYNDICATE__.QuasiValue.finish((__SYNDICATE__.QuasiValue.lit(__SYNDICATE__.fromJS(P)))),
+        observer: __SYNDICATE__.Turn.ref(__SYNDICATE__.assertionFacetObserver(
+            (__vs) => {
+                if (Array.isArray(__vs)) {
+
+                    a;
+                    __SYNDICATE__.Turn.active._stop(currentSyndicateFacet, () => {
+                        const currentSyndicateFacet = __SYNDICATE__.Turn.activeFacet;
+                    });
+                    b;
                 }
-            ))
-        }) }));`);
-    });
+            }
+        ))
+    })
+}));`));
+
 });
 
 describe('once', () => {
-    it('basics with block', () => {
-        expect(translateNoErrors(`once asserted P => { a; b; }`)).toBe(
-            `__SYNDICATE__.Turn.active.facet(() => {const __once_facet = __SYNDICATE__.Turn.activeFacet; __SYNDICATE__.Turn.active.assertDataflow(() => ({
-                target: currentSyndicateTarget,
-                assertion: __SYNDICATE__.Observe({
+    it('basics with block', () => expectCodeEqual(`once asserted P => { a; b; }`, `
+__SYNDICATE__.Turn.active.facet(() => {
+    const __once_facet = __SYNDICATE__.Turn.activeFacet;
+    __SYNDICATE__.Turn.active.assertDataflow(() => ({
+        target: currentSyndicateTarget,
+        assertion: __SYNDICATE__.Observe({
             pattern: __SYNDICATE__.QuasiValue.finish((__SYNDICATE__.QuasiValue.lit(__SYNDICATE__.fromJS(P)))),
             observer: __SYNDICATE__.Turn.ref({
-                    assert: (__vs, __handle) => {
-                        if (Array.isArray(__vs)) {
+                assert: (__vs, __handle) => {
+                    if (Array.isArray(__vs)) {
 
-            __SYNDICATE__.Turn.active._stop(__once_facet, () => { a; b; })
-        }
+                        __SYNDICATE__.Turn.active._stop(__once_facet, () => { a; b; })
                     }
-                }),
+                }
+            }),
         }),
-            }));});`);
-    });
-    it('basics with statement', () => {
-        expect(translateNoErrors(`once asserted P => x;`)).toBe(
-            `__SYNDICATE__.Turn.active.facet(() => {const __once_facet = __SYNDICATE__.Turn.activeFacet; __SYNDICATE__.Turn.active.assertDataflow(() => ({
-                target: currentSyndicateTarget,
-                assertion: __SYNDICATE__.Observe({
+    }));
+});`));
+
+    it('basics with statement', () => expectCodeEqual(`once asserted P => x;`, `
+__SYNDICATE__.Turn.active.facet(() => {
+    const __once_facet = __SYNDICATE__.Turn.activeFacet;
+    __SYNDICATE__.Turn.active.assertDataflow(() => ({
+        target: currentSyndicateTarget,
+        assertion: __SYNDICATE__.Observe({
             pattern: __SYNDICATE__.QuasiValue.finish((__SYNDICATE__.QuasiValue.lit(__SYNDICATE__.fromJS(P)))),
             observer: __SYNDICATE__.Turn.ref({
-                    assert: (__vs, __handle) => {
-                        if (Array.isArray(__vs)) {
+                assert: (__vs, __handle) => {
+                    if (Array.isArray(__vs)) {
 
-            __SYNDICATE__.Turn.active._stop(__once_facet, () => {x;})
-        }
+                        __SYNDICATE__.Turn.active._stop(__once_facet, () => {x;})
                     }
-                }),
+                }
+            }),
         }),
-            }));});`);
-    });
+    }));
+});`));
+
 });

No alert changes

Improved metrics

Lines of code

8362

increased by0.26%

Worsened metrics

Total package byte prevSize

1021987

decreased by-0.03%

Dev dependency count

2

increased byInfinity%

No dependency changes