jssm 5.35.4 → 5.42.0

package/src/ts/tests/cycles.spec.ts

@@ -1,153 +1,153 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-
-
-
-
-const testdata = [
-
-  [
-    'basic cycle',
-    '[a b c] -> +1;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 1}}}]
-  ],
-
-  [
-    'negative cycle',
-    '[a b c] -> -1;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: -1}}}]
-  ],
-
-  [
-    'nullary cycle',
-    '[a b c] -> +0;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 0}}}]
-  ],
-
-  [
-    'wide cycle',
-    '[a b c] -> +2;',
-    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 2}}}]
-  ],
-
-  [
-    'reverse basic cycle',
-    '+1 <- [a b c];',
-    [{from: {key: 'cycle', value: 1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse negative cycle',
-    '-1 <- [a b c];',
-    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse nullary cycle',
-    '+0 <- [a b c];',
-    [{from: {key: 'cycle', value: 0}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'reverse wide cycle',
-    '+2 <- [a b c];',
-    [{from: {key: 'cycle', value: 2}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi basic cycle',
-    '+1 <- [a b c] -> +1;',
-    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi negative cycle',
-    '-1 <- [a b c] -> -1;',
-    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi basic/negative cycle',
-    '+1 <- [a b c] -> -1;',
-    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi nullary cycle',
-    '+0 <- [a b c] -> +0;',
-    [{from: {key: 'cycle', value:  0}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  0}}, to: ['a','b','c']}}]
-  ],
-
-  [
-    'bidi wide cycle',
-    '+2 <- [a b c] -> -2;',
-    [{from: {key: 'cycle', value:  2}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -2}}, to: ['a','b','c']}}]
-  ]
-
-];
-
-
-
-
-
-describe('cycle strategies', () => {
-
-
-  const is_v = (label, str, v) =>
-    test(`${label} (strategy ${str})`, () =>
-      expect( jssm.parse(str) ).toEqual(v) );
-
-  testdata.map( ([ label, code, res ]) => is_v(label, code, res) );
-
-  test.todo('cycle full parses');
-
-/*
-  describe('full parse of 2-step cycle', () => {
-    it('[a b] -> +1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-
-  describe('full parse of 5-step cycle', () => {
-    it('[a b c d e] -> +1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"d","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"a","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-
-  describe('full parse of 5-step reverse cycle', () => {
-    it('[a b c d e] -> -1;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"b","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"d","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-
-  describe('full parse of 5-step two-step cycle (star)', () => {
-    it('[a b c d e] -> +2;', t => t.deepEqual(
-      sm`[a b] -> +1;`.list_edges(),
-      [{"from":"a","to":"c","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"b","to":"d","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"c","to":"e","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"d","to":"a","kind":"legal","forced_only":false,"main_path":false},
-       {"from":"e","to":"b","kind":"legal","forced_only":false,"main_path":false}]
-    ));
-  });
-*/
-
-});
-
-test('illegal fractional cycle throws', () => {
-  expect( () => jssm.parse('[a b c] -> +2.5;') ).toThrow();
-});
+
+/* eslint-disable max-len */
+
+import * as jssm from '../jssm';
+
+
+
+
+
+const testdata = [
+
+  [
+    'basic cycle',
+    '[a b c] -> +1;',
+    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 1}}}]
+  ],
+
+  [
+    'negative cycle',
+    '[a b c] -> -1;',
+    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: -1}}}]
+  ],
+
+  [
+    'nullary cycle',
+    '[a b c] -> +0;',
+    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 0}}}]
+  ],
+
+  [
+    'wide cycle',
+    '[a b c] -> +2;',
+    [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'cycle', value: 2}}}]
+  ],
+
+  [
+    'reverse basic cycle',
+    '+1 <- [a b c];',
+    [{from: {key: 'cycle', value: 1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
+  ],
+
+  [
+    'reverse negative cycle',
+    '-1 <- [a b c];',
+    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
+  ],
+
+  [
+    'reverse nullary cycle',
+    '+0 <- [a b c];',
+    [{from: {key: 'cycle', value: 0}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
+  ],
+
+  [
+    'reverse wide cycle',
+    '+2 <- [a b c];',
+    [{from: {key: 'cycle', value: 2}, key: 'transition', se: {kind: '<-', to: ['a','b','c']}}]
+  ],
+
+  [
+    'bidi basic cycle',
+    '+1 <- [a b c] -> +1;',
+    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  1}}, to: ['a','b','c']}}]
+  ],
+
+  [
+    'bidi negative cycle',
+    '-1 <- [a b c] -> -1;',
+    [{from: {key: 'cycle', value: -1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
+  ],
+
+  [
+    'bidi basic/negative cycle',
+    '+1 <- [a b c] -> -1;',
+    [{from: {key: 'cycle', value:  1}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -1}}, to: ['a','b','c']}}]
+  ],
+
+  [
+    'bidi nullary cycle',
+    '+0 <- [a b c] -> +0;',
+    [{from: {key: 'cycle', value:  0}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value:  0}}, to: ['a','b','c']}}]
+  ],
+
+  [
+    'bidi wide cycle',
+    '+2 <- [a b c] -> -2;',
+    [{from: {key: 'cycle', value:  2}, key: 'transition', se: {kind: '<-', se: {kind: '->', to: {key: 'cycle', value: -2}}, to: ['a','b','c']}}]
+  ]
+
+];
+
+
+
+
+
+describe('cycle strategies', () => {
+
+
+  const is_v = (label, str, v) =>
+    test(`${label} (strategy ${str})`, () =>
+      expect( jssm.parse(str) ).toEqual(v) );
+
+  testdata.map( ([ label, code, res ]) => is_v(label, code, res) );
+
+  test.todo('cycle full parses');
+
+/*
+  describe('full parse of 2-step cycle', () => {
+    it('[a b] -> +1;', t => t.deepEqual(
+      sm`[a b] -> +1;`.list_edges(),
+      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false}]
+    ));
+  });
+
+  describe('full parse of 5-step cycle', () => {
+    it('[a b c d e] -> +1;', t => t.deepEqual(
+      sm`[a b] -> +1;`.list_edges(),
+      [{"from":"a","to":"b","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"b","to":"c","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"c","to":"d","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"d","to":"e","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"e","to":"a","kind":"legal","forced_only":false,"main_path":false}]
+    ));
+
+  describe('full parse of 5-step reverse cycle', () => {
+    it('[a b c d e] -> -1;', t => t.deepEqual(
+      sm`[a b] -> +1;`.list_edges(),
+      [{"from":"a","to":"e","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"b","to":"a","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"c","to":"b","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"d","to":"c","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"e","to":"d","kind":"legal","forced_only":false,"main_path":false}]
+    ));
+  });
+
+  describe('full parse of 5-step two-step cycle (star)', () => {
+    it('[a b c d e] -> +2;', t => t.deepEqual(
+      sm`[a b] -> +1;`.list_edges(),
+      [{"from":"a","to":"c","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"b","to":"d","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"c","to":"e","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"d","to":"a","kind":"legal","forced_only":false,"main_path":false},
+       {"from":"e","to":"b","kind":"legal","forced_only":false,"main_path":false}]
+    ));
+  });
+*/
+
+});
+
+test('illegal fractional cycle throws', () => {
+  expect( () => jssm.parse('[a b c] -> +2.5;') ).toThrow();
+});

package/src/ts/tests/dot_preamble.spec.ts

@@ -1,16 +1,16 @@
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('Dot preamble', () => {
-
-  test(`doesn't throw`, () =>
-    expect( () => { const _foo = sm`dot_preamble: "x -> y;"; a-> b;`; }).not.toThrow() );
-
-  test('parses correctly', () =>
-    expect( sm`dot_preamble: "x -> y;"; a-> b;`.dot_preamble() ).toBe('x -> y;') );
-
-});
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('Dot preamble', () => {
+
+  test(`doesn't throw`, () =>
+    expect( () => { const _foo = sm`dot_preamble: "x -> y;"; a-> b;`; }).not.toThrow() );
+
+  test('parses correctly', () =>
+    expect( sm`dot_preamble: "x -> y;"; a-> b;`.dot_preamble() ).toBe('x -> y;') );
+
+});

package/src/ts/tests/embedded_sm.spec.ts

@@ -1,36 +1,36 @@
-
-import { sm } from '../jssm';
-
-
-
-
-
-const testdata = [
-  'a -> b;',
-  'flow: right; a -> b -> c -> d -> a;'
-];
-
-const host = sm`x -> y;`;
-
-
-
-
-
-describe('Embedded sm parses the same as regular sm', () => {
-
-  testdata.map(code => {
-
-    test(`Self-match of \`${code}\``, () => {
-      expect( sm`${code}` ).toEqual( host.sm`${code}` );
-    });
-
-  });
-
-});
-
-
-
-
-
-test.todo('Boy is this embedded sm matching thing ever a candidate for stochastics');
-// stochable
+
+import { sm } from '../jssm';
+
+
+
+
+
+const testdata = [
+  'a -> b;',
+  'flow: right; a -> b -> c -> d -> a;'
+];
+
+const host = sm`x -> y;`;
+
+
+
+
+
+describe('Embedded sm parses the same as regular sm', () => {
+
+  testdata.map(code => {
+
+    test(`Self-match of \`${code}\``, () => {
+      expect( sm`${code}` ).toEqual( host.sm`${code}` );
+    });
+
+  });
+
+});
+
+
+
+
+
+test.todo('Boy is this embedded sm matching thing ever a candidate for stochastics');
+// stochable

package/src/ts/tests/flow.spec.ts

@@ -1,22 +1,22 @@
-
-import { FlowDirections } from './constants.spec';
-import { sm }             from '../jssm';
-
-
-
-
-
-describe('Flow directions', () => {
-
-  FlowDirections.map( thisDir =>
-    test(`Direction "${thisDir}" parses as a flow direction`, () =>
-      expect( () => { const _foo = sm`flow: ${thisDir}; a-> b;`; }).not.toThrow() ) );
-
-  FlowDirections.map( thisDir =>
-    test(`Direction "${thisDir}" parses correctly`, () =>
-      expect( sm`flow: ${thisDir}; a-> b;`.flow() ).toBe(thisDir) ) );
-
-  test('Fake flow direction throws', () =>
-    expect( () => { const _foo = sm`flow: yourFlowIsWhackSon; a-> b;`; } ).toThrow() );
-
-});
+
+import { FlowDirections } from './constants.spec';
+import { sm }             from '../jssm';
+
+
+
+
+
+describe('Flow directions', () => {
+
+  FlowDirections.map( thisDir =>
+    test(`Direction "${thisDir}" parses as a flow direction`, () =>
+      expect( () => { const _foo = sm`flow: ${thisDir}; a-> b;`; }).not.toThrow() ) );
+
+  FlowDirections.map( thisDir =>
+    test(`Direction "${thisDir}" parses correctly`, () =>
+      expect( sm`flow: ${thisDir}; a-> b;`.flow() ).toBe(thisDir) ) );
+
+  test('Fake flow direction throws', () =>
+    expect( () => { const _foo = sm`flow: yourFlowIsWhackSon; a-> b;`; } ).toThrow() );
+
+});

package/src/ts/tests/forced transitions.spec.ts

@@ -1,26 +1,26 @@
-
-/* eslint-disable max-len */
-
-import { sm } from '../jssm';
-
-
-
-
-
-describe('reject and accept correctly', () => {
-
-  const machine = sm` a ~> b -> c; `;
-
-  test('starts in a',                    () => expect( machine.state()               ).toBe('a')   );
-  test('rejects transition to b',        () => expect( machine.transition('b')       ).toBe(false) );
-  test('still in a',                     () => expect( machine.state()               ).toBe('a')   );
-  test('rejects transition to c',        () => expect( machine.transition('c')       ).toBe(false) );
-  test('still in a 2',                   () => expect( machine.state()               ).toBe('a')   );
-  test('rejects forced transition to c', () => expect( machine.force_transition('c') ).toBe(false) );
-  test('still in a 3',                   () => expect( machine.state()               ).toBe('a')   );
-  test('accepts forced transition to b', () => expect( machine.force_transition('b') ).toBe(true)  );
-  test('now in b',                       () => expect( machine.state()               ).toBe('b')   );
-  test('accepts transition to c',        () => expect( machine.transition('c')       ).toBe(true)  );
-  test('now in c',                       () => expect( machine.state()               ).toBe('c')   );
-
-});
+
+/* eslint-disable max-len */
+
+import { sm } from '../jssm';
+
+
+
+
+
+describe('reject and accept correctly', () => {
+
+  const machine = sm` a ~> b -> c; `;
+
+  test('starts in a',                    () => expect( machine.state()               ).toBe('a')   );
+  test('rejects transition to b',        () => expect( machine.transition('b')       ).toBe(false) );
+  test('still in a',                     () => expect( machine.state()               ).toBe('a')   );
+  test('rejects transition to c',        () => expect( machine.transition('c')       ).toBe(false) );
+  test('still in a 2',                   () => expect( machine.state()               ).toBe('a')   );
+  test('rejects forced transition to c', () => expect( machine.force_transition('c') ).toBe(false) );
+  test('still in a 3',                   () => expect( machine.state()               ).toBe('a')   );
+  test('accepts forced transition to b', () => expect( machine.force_transition('b') ).toBe(true)  );
+  test('now in b',                       () => expect( machine.state()               ).toBe('b')   );
+  test('accepts transition to c',        () => expect( machine.transition('c')       ).toBe(true)  );
+  test('now in c',                       () => expect( machine.state()               ).toBe('c')   );
+
+});