jssm 5.35.4 → 5.42.0

package/src/ts/tests/machine_name.spec.ts

@@ -1,14 +1,14 @@
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('machine name', () => {
-
-  test('doesn\'t throw', () =>
-    expect( () => { const _foo = sm`machine_name: bob; a->b;`; }).not.toThrow()
-  );
-
-});
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('machine name', () => {
+
+  test('doesn\'t throw', () =>
+    expect( () => { const _foo = sm`machine_name: bob; a->b;`; }).not.toThrow()
+  );
+
+});

package/src/ts/tests/named lists.spec.ts

@@ -1,19 +1,24 @@
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('named lists', () => {
-
-  test('alone', () =>
-    expect(() => { jssm.parse('&b: [a c e];'); }).not.toThrow() );
-
-  test('before trans', () =>
-    expect(() => { jssm.parse('&b: [a c e]; a->c;'); }).not.toThrow() );
-
-  test('after trans', () =>
-    expect(() => { jssm.parse('a->c; &b: [a c e];'); }).not.toThrow() );
-
-});
+
+import * as jssm from '../jssm';
+
+
+
+
+
+// TODO these tests only assert non-crashing
+// That amn't very good, sah
+
+test.todo('Assert better than non-crashing in named lists.spec.ts');
+
+describe('named lists', () => {
+
+  test('alone', () =>
+    expect(() => { jssm.parse('&b: [a c e];'); }).not.toThrow() );
+
+  test('before trans', () =>
+    expect(() => { jssm.parse('&b: [a c e]; a->c;'); }).not.toThrow() );
+
+  test('after trans', () =>
+    expect(() => { jssm.parse('a->c; &b: [a c e];'); }).not.toThrow() );
+
+});

package/src/ts/tests/nominated states.spec.ts

@@ -1,133 +1,133 @@
-
-import * as jssm from '../jssm';
-
-const sm   = jssm.sm,
-      jp   = jssm.parse;
-
-
-
-
-
-describe('simple naming', () => {
-
-
-
-  describe('parse', () => {
-
-    test('trans then node', () =>
-      expect(() => {
-        jp('a -> b; state a: { color: orange; };');
-      }).not.toThrow() );
-
-    test('node then trans', () =>
-      expect(() => {
-        jp('state a: { color: orange; }; a -> b;');
-      }).not.toThrow() );
-
-    test('cycle node named', () =>
-      expect(() => {
-        jp('[a b] -> +1; state a: { color: red; }; &b: [a c e];');
-      }).not.toThrow() );
-
-    test('two properties', () =>
-      expect(() => {
-        jp('a -> b; state a: { color: orange; shape: circle; };');
-      }).not.toThrow() );
-
-  });
-
-
-
-  describe('sm tag', () => {
-
-    test('trans then node', () =>
-      expect(() => {
-        sm`a -> b; state a: { color: orange; };`;
-      }).not.toThrow() );
-
-    test('node then trans', () =>
-      expect(() => {
-        sm`state a: { color: orange; }; a -> b;`;
-    }).not.toThrow() );
-
-    test.todo('Uncomment when named nodes work');
-
-//  test('cycle node named', () =>
-//    expect(() => {
-//      sm`[a b] -> +1; state a: { color: red; }; &b: [a c e];`;
-//    }).not.toThrow() );
-
-    test('two properties', () =>
-      expect(() => {
-        sm`a -> b; state a: { color: orange; shape: circle; };`;
-      }).not.toThrow() );
-
-  });
-
-});
-
-
-
-
-
-describe('spacing variants', () => {
-
-  test('tight', () =>
-    expect(() => {
-      jp('a -> b; state a:{color:orange;};');
-    }).not.toThrow() );
-
-  test('framed', () =>
-    expect(() => {
-      jp('a -> b; state a:{ color:orange; };');
-    }).not.toThrow() );
-
-  test('sentence', () =>
-    expect(() => {
-      jp('a -> b; state a:{ color: orange; };');
-    }).not.toThrow() );
-
-  test('fully', () =>
-    expect(() => {
-      jp('a -> b; state a:{ color : orange; };');
-    }).not.toThrow() );
-
-  test('mars', () =>
-    expect(() => {
-      jp('a -> b; state a:{color : orange;};');
-    }).not.toThrow() );
-
-});
-
-
-
-
-
-describe('properties', () => {
-
-  test('color', () =>
-
-    expect(
-     sm`a -> b; state a:{color:orange;};`.raw_state_declarations()[0]
-    ).toEqual(
-      {state:'a', color:'#ffa500ff', declarations:[{key: "color", value: "#ffa500ff"}]}
-    )
-
-  );
-
-});
-
-
-
-
-
-test.todo('More to do in nominated states');
-
-
-
-
-
-// TODO FIXME TESTME test state_delarations/0
-// TODO FIXME TESTME test state_delaration/1 for has
-// TODO FIXME TESTME test state_delaration/1 for doesn't have
-// TODO FIXME TESTME test that redeclaring a state throws
+
+import * as jssm from '../jssm';
+
+const sm   = jssm.sm,
+      jp   = jssm.parse;
+
+
+
+
+
+describe('simple naming', () => {
+
+
+
+  describe('parse', () => {
+
+    test('trans then node', () =>
+      expect(() => {
+        jp('a -> b; state a: { color: orange; };');
+      }).not.toThrow() );
+
+    test('node then trans', () =>
+      expect(() => {
+        jp('state a: { color: orange; }; a -> b;');
+      }).not.toThrow() );
+
+    test('cycle node named', () =>
+      expect(() => {
+        jp('[a b] -> +1; state a: { color: red; }; &b: [a c e];');
+      }).not.toThrow() );
+
+    test('two properties', () =>
+      expect(() => {
+        jp('a -> b; state a: { color: orange; shape: circle; };');
+      }).not.toThrow() );
+
+  });
+
+
+
+  describe('sm tag', () => {
+
+    test('trans then node', () =>
+      expect(() => {
+        sm`a -> b; state a: { color: orange; };`;
+      }).not.toThrow() );
+
+    test('node then trans', () =>
+      expect(() => {
+        sm`state a: { color: orange; }; a -> b;`;
+    }).not.toThrow() );
+
+    test.todo('Uncomment when named nodes work');
+
+//  test('cycle node named', () =>
+//    expect(() => {
+//      sm`[a b] -> +1; state a: { color: red; }; &b: [a c e];`;
+//    }).not.toThrow() );
+
+    test('two properties', () =>
+      expect(() => {
+        sm`a -> b; state a: { color: orange; shape: circle; };`;
+      }).not.toThrow() );
+
+  });
+
+});
+
+
+
+
+
+describe('spacing variants', () => {
+
+  test('tight', () =>
+    expect(() => {
+      jp('a -> b; state a:{color:orange;};');
+    }).not.toThrow() );
+
+  test('framed', () =>
+    expect(() => {
+      jp('a -> b; state a:{ color:orange; };');
+    }).not.toThrow() );
+
+  test('sentence', () =>
+    expect(() => {
+      jp('a -> b; state a:{ color: orange; };');
+    }).not.toThrow() );
+
+  test('fully', () =>
+    expect(() => {
+      jp('a -> b; state a:{ color : orange; };');
+    }).not.toThrow() );
+
+  test('mars', () =>
+    expect(() => {
+      jp('a -> b; state a:{color : orange;};');
+    }).not.toThrow() );
+
+});
+
+
+
+
+
+describe('properties', () => {
+
+  test('color', () =>
+
+    expect(
+     sm`a -> b; state a:{color:orange;};`.raw_state_declarations()[0]
+    ).toEqual(
+      {state:'a', color:'#ffa500ff', declarations:[{key: "color", value: "#ffa500ff"}]}
+    )
+
+  );
+
+});
+
+
+
+
+
+test.todo('More to do in nominated states');
+
+
+
+
+
+// TODO FIXME TESTME test state_delarations/0
+// TODO FIXME TESTME test state_delaration/1 for has
+// TODO FIXME TESTME test state_delaration/1 for doesn't have
+// TODO FIXME TESTME test that redeclaring a state throws

package/src/ts/tests/parse actions.spec.ts

@@ -1,32 +1,32 @@
-
-/* eslint-disable max-len */
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('matter', () => {
-
-    const matter = sm` Solid 'Heat' <-> 'Cool' Liquid 'Heat' <-> 'Cool' Gas 'Heat' <-> 'Cool' Plasma; `;
-
-    test( 'starts Solid',    () => expect(matter.state()        ).toBe( 'Solid'  ) );
-    test( 'Heat is true',    () => expect(matter.action('Heat') ).toBe( true     ) );
-    test( 'is now Liquid',   () => expect(matter.state()        ).toBe( 'Liquid' ) );
-    test( 'Heat is true 2',  () => expect(matter.action('Heat') ).toBe( true     ) );
-    test( 'is now Gas',      () => expect(matter.state()        ).toBe( 'Gas'    ) );
-    test( 'Heat is true 3',  () => expect(matter.action('Heat') ).toBe( true     ) );
-    test( 'is now Plasma',   () => expect(matter.state()        ).toBe( 'Plasma' ) );
-    test( 'Heat is false',   () => expect(matter.action('Heat') ).toBe( false    ) );
-    test( 'is now Plasma 2', () => expect(matter.state()        ).toBe( 'Plasma' ) );
-    test( 'Cool is true',    () => expect(matter.action('Cool') ).toBe( true     ) );
-    test( 'is now Gas 2',    () => expect(matter.state()        ).toBe( 'Gas'    ) );
-    test( 'Cool is true 2',  () => expect(matter.action('Cool') ).toBe( true     ) );
-    test( 'is now Liquid 2', () => expect(matter.state()        ).toBe( 'Liquid' ) );
-    test( 'Cool is true 3',  () => expect(matter.action('Cool') ).toBe( true     ) );
-    test( 'is now Solid',    () => expect(matter.state()        ).toBe( 'Solid'  ) );
-    test( 'Cool is false',   () => expect(matter.action('Cool') ).toBe( false    ) );
-    test( 'is now Solid 2',  () => expect(matter.state()        ).toBe( 'Solid'  ) );
-
-});
+
+/* eslint-disable max-len */
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('matter', () => {
+
+    const matter = sm` Solid 'Heat' <-> 'Cool' Liquid 'Heat' <-> 'Cool' Gas 'Heat' <-> 'Cool' Plasma; `;
+
+    test( 'starts Solid',    () => expect(matter.state()        ).toBe( 'Solid'  ) );
+    test( 'Heat is true',    () => expect(matter.action('Heat') ).toBe( true     ) );
+    test( 'is now Liquid',   () => expect(matter.state()        ).toBe( 'Liquid' ) );
+    test( 'Heat is true 2',  () => expect(matter.action('Heat') ).toBe( true     ) );
+    test( 'is now Gas',      () => expect(matter.state()        ).toBe( 'Gas'    ) );
+    test( 'Heat is true 3',  () => expect(matter.action('Heat') ).toBe( true     ) );
+    test( 'is now Plasma',   () => expect(matter.state()        ).toBe( 'Plasma' ) );
+    test( 'Heat is false',   () => expect(matter.action('Heat') ).toBe( false    ) );
+    test( 'is now Plasma 2', () => expect(matter.state()        ).toBe( 'Plasma' ) );
+    test( 'Cool is true',    () => expect(matter.action('Cool') ).toBe( true     ) );
+    test( 'is now Gas 2',    () => expect(matter.state()        ).toBe( 'Gas'    ) );
+    test( 'Cool is true 2',  () => expect(matter.action('Cool') ).toBe( true     ) );
+    test( 'is now Liquid 2', () => expect(matter.state()        ).toBe( 'Liquid' ) );
+    test( 'Cool is true 3',  () => expect(matter.action('Cool') ).toBe( true     ) );
+    test( 'is now Solid',    () => expect(matter.state()        ).toBe( 'Solid'  ) );
+    test( 'Cool is false',   () => expect(matter.action('Cool') ).toBe( false    ) );
+    test( 'is now Solid 2',  () => expect(matter.state()        ).toBe( 'Solid'  ) );
+
+});

package/src/ts/tests/parse.spec.ts

@@ -1,94 +1,94 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('parse/1', () => {
-
-  describe('forward arrow', () => {
-
-    const AtoB = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b"}}],
-          AdB  = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","l_desc": [{"key":"arc_label","value":"d"}]}}],
-          ABd  = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","r_desc": [{"key":"arc_label","value":"d"}]}}],
-          AdBd = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","l_desc": [{"key":"arc_label","value":"d"}],"r_desc": [{"key":"arc_label","value":"f"}]}}];
-
-    const echo_equal = (testt, validator) =>
-      test(testt, () =>
-        expect(jssm.parse(testt))
-          .toEqual(validator) );
-
-    const ShouldEqualAtoB = ['a->b;', 'a ->b;', 'a-> b;', 'a -> b;', 'a{}->b;', 'a->{}b;', 'a{}->{}b;'];
-    ShouldEqualAtoB.map(p => echo_equal(p, AtoB));
-
-    echo_equal('a{arc_label:d;}->b;',               AdB);
-    echo_equal('a{arc_label:"d";}->b;',             AdB);
-    echo_equal('a->{arc_label:d;}b;',               ABd);
-    echo_equal('a{arc_label:d;}->{arc_label:f;}b;', AdBd);
-
-  });
-
-  describe('double arrow', () => {
-
-    const AtoB = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b"}}],
-          AdB  = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","l_desc": [{"key":"arc_label","value":"d"}]}}],
-          ABd  = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","r_desc": [{"key":"arc_label","value":"d"}]}}],
-          AdBd = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","l_desc": [{"key":"arc_label","value":"d"}],"r_desc": [{"key":"arc_label","value":"f"}]}}];
-
-    const echo_equal = (testt, validator) =>
-      test(testt, () =>
-        expect(jssm.parse(testt))
-          .toEqual(validator) );
-
-    const ShouldEqualAtoB = ['a<->b;', 'a <->b;', 'a<-> b;', 'a <-> b;', 'a{}<->b;', 'a<->{}b;', 'a{}<->{}b;'];
-    ShouldEqualAtoB.map(p => echo_equal(p, AtoB));
-
-    echo_equal('a{arc_label:d;}<->b;',               AdB);
-    echo_equal('a{arc_label:"d";}<->b;',             AdB);
-    echo_equal('a<->{arc_label:d;}b;',               ABd);
-    echo_equal('a{arc_label:d;}<->{arc_label:f;}b;', AdBd);
-
-  });
-
-  describe('chain', () => {
-    const AtoBtoC = [{"key":"transition","from":"a","se":{"kind":"->","to":"b","se":{"kind":"->","to":"c"}}}];
-    test('a->b->c;', () =>
-      expect( jssm.parse('a->b->c;') )
-        .toEqual(AtoBtoC) );
-  });
-
-  describe('sequence', () => {
-    const AtoB_CtoD = [{"key":"transition","from":"a","se":{"kind":"->","to":"b"}},{"key":"transition","from":"c","se":{"kind":"->","to":"d"}}];
-    test('a->b;c->d;', () =>
-      expect( jssm.parse('a->b;c->d;') )
-        .toEqual(AtoB_CtoD) );
-  });
-
-  test.todo('graph inputs, graph outputs in parse.spec');
-
-  // todo: graph: {inputs: [foo]}
-  // todo: graph: {outputs: [foo]}
-
-  test.todo('improve torture in parse.spec');
-
-  describe('torture', () => {
-
-    const augh = `
-      a->b-> c-> d -> e
-->
-f <- g <= h <-> i <=> j ~> k <~ l <~> m <~-> n <-~> o <=~> p <~=> q <-=> r <=-> s 'A' <= 'B' t;
-
-a ← b2 ⇐ c2 ↚ d2 → e2 ⇒ f2 ↛ g2 ↔ h2 ⇔ i2 ↮ j2 ←⇒ k2 ⇐→ l2 ←↛ m2 ↚→ n2 ⇐↛ o2 ↚⇒ p2;
-
-`;
-
-    test('doesn\'t throw', () => expect(() => { jssm.parse(augh); }).not.toThrow() );
-
-  });
-
-});
-
-// stochable
+
+/* eslint-disable max-len */
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('parse/1', () => {
+
+  describe('forward arrow', () => {
+
+    const AtoB = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b"}}],
+          AdB  = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","l_desc": [{"key":"arc_label","value":"d"}]}}],
+          ABd  = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","r_desc": [{"key":"arc_label","value":"d"}]}}],
+          AdBd = [{"key": "transition", "from": "a", "se": {"kind": "->","to": "b","l_desc": [{"key":"arc_label","value":"d"}],"r_desc": [{"key":"arc_label","value":"f"}]}}];
+
+    const echo_equal = (testt, validator) =>
+      test(testt, () =>
+        expect(jssm.parse(testt))
+          .toEqual(validator) );
+
+    const ShouldEqualAtoB = ['a->b;', 'a ->b;', 'a-> b;', 'a -> b;', 'a{}->b;', 'a->{}b;', 'a{}->{}b;'];
+    ShouldEqualAtoB.map(p => echo_equal(p, AtoB));
+
+    echo_equal('a{arc_label:d;}->b;',               AdB);
+    echo_equal('a{arc_label:"d";}->b;',             AdB);
+    echo_equal('a->{arc_label:d;}b;',               ABd);
+    echo_equal('a{arc_label:d;}->{arc_label:f;}b;', AdBd);
+
+  });
+
+  describe('double arrow', () => {
+
+    const AtoB = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b"}}],
+          AdB  = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","l_desc": [{"key":"arc_label","value":"d"}]}}],
+          ABd  = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","r_desc": [{"key":"arc_label","value":"d"}]}}],
+          AdBd = [{"key": "transition", "from": "a", "se": {"kind": "<->","to": "b","l_desc": [{"key":"arc_label","value":"d"}],"r_desc": [{"key":"arc_label","value":"f"}]}}];
+
+    const echo_equal = (testt, validator) =>
+      test(testt, () =>
+        expect(jssm.parse(testt))
+          .toEqual(validator) );
+
+    const ShouldEqualAtoB = ['a<->b;', 'a <->b;', 'a<-> b;', 'a <-> b;', 'a{}<->b;', 'a<->{}b;', 'a{}<->{}b;'];
+    ShouldEqualAtoB.map(p => echo_equal(p, AtoB));
+
+    echo_equal('a{arc_label:d;}<->b;',               AdB);
+    echo_equal('a{arc_label:"d";}<->b;',             AdB);
+    echo_equal('a<->{arc_label:d;}b;',               ABd);
+    echo_equal('a{arc_label:d;}<->{arc_label:f;}b;', AdBd);
+
+  });
+
+  describe('chain', () => {
+    const AtoBtoC = [{"key":"transition","from":"a","se":{"kind":"->","to":"b","se":{"kind":"->","to":"c"}}}];
+    test('a->b->c;', () =>
+      expect( jssm.parse('a->b->c;') )
+        .toEqual(AtoBtoC) );
+  });
+
+  describe('sequence', () => {
+    const AtoB_CtoD = [{"key":"transition","from":"a","se":{"kind":"->","to":"b"}},{"key":"transition","from":"c","se":{"kind":"->","to":"d"}}];
+    test('a->b;c->d;', () =>
+      expect( jssm.parse('a->b;c->d;') )
+        .toEqual(AtoB_CtoD) );
+  });
+
+  test.todo('graph inputs, graph outputs in parse.spec');
+
+  // todo: graph: {inputs: [foo]}
+  // todo: graph: {outputs: [foo]}
+
+  test.todo('improve torture in parse.spec');
+
+  describe('torture', () => {
+
+    const augh = `
+      a->b-> c-> d -> e
+->
+f <- g <= h <-> i <=> j ~> k <~ l <~> m <~-> n <-~> o <=~> p <~=> q <-=> r <=-> s 'A' <= 'B' t;
+
+a ← b2 ⇐ c2 ↚ d2 → e2 ⇒ f2 ↛ g2 ↔ h2 ⇔ i2 ↮ j2 ←⇒ k2 ⇐→ l2 ←↛ m2 ↚→ n2 ⇐↛ o2 ↚⇒ p2;
+
+`;
+
+    test('doesn\'t throw', () => expect(() => { jssm.parse(augh); }).not.toThrow() );
+
+  });
+
+});
+
+// stochable