risei 1.3.4 → 2.0.1

package/system/{TestDefinition.js → TestDef.js}

@@ -1,23 +1,20 @@
 /**/
 
-import { TypeAnalyzer } from "./TypeAnalyzer.js";
-import { TypeIdentifier } from "./TypeIdentifier.js";
-import { Types } from "./Types.js";
-import { TotalCopier } from "./TotalCopier.js";
+import TypeAnalyzer from "./TypeAnalyzer.js";
+import NameAnalyzer from "./NameAnalyzer.js";
+import TypeIdentifier from "./TypeIdentifier.js";
+import Types from "./Types.js";
 
-/* Defines what is found in a test-definition tuple (TDT).  Actual TDTs don't need to be instances of this class. */
+/* Defines what is found in a test definition, typically as 
+   a nonce object rather than an instance of this class. */
 
-export class TestDefinition {
+export default class TestDef {
     // region Definitions
 
     static staticName = "static";
     static throwName = "throw";
     static constructorName = "constructor";
-    static nonceLocalCallableName = "localCallable";
-    static dotOperator = ".";
-    static colonOperator = ":";
-    static parensOperator = "()";
-    static operatorsRegExp = /\.|:|\(\)/g;
+    static nonceLocalCallableName = "nonce";
 
     // endregion Definitions
 
@@ -29,17 +26,14 @@ export class TestDefinition {
         [ "with", "initors" ],
         [ "of", "method" ],
         [ "plus", "spoofed" ],
-        [ "amid", "settables" ],
         [ "in", "inputs" ],
         [ "out", "output" ],
         [ "from", "source" ],
-        [ "and", "factors" ]
+        [ "and", "factors" ],
+        [ "do", "enact" ],
+        [ "undo", "counteract" ]
     ]);
 
-    static #copier = new TotalCopier();
-
-    static #identifier = new TypeIdentifier();
-
     // endregion Static fields
 
     // region Fields
@@ -52,14 +46,14 @@ export class TestDefinition {
     initors;
     method;
     spoofed;
-    settables;
     inputs;
     output;
     source;
     factors;
+    enact;
+    counteract;
 
     target;
-    localCallable;
     
     actual;
     thrown;
@@ -112,15 +106,6 @@ export class TestDefinition {
         this.spoofed = value;
     }
     
-    /* &cruft, drop or rename this .amid property pair */
-    get amid() { 
-        return this.settables; 
-    }
-    
-    set amid(value) { 
-        this.settables = value; 
-    }
-
     get in() {
         return this.inputs;
     }
@@ -153,11 +138,27 @@ export class TestDefinition {
         this.factors = value;
     }
 
+    get do() {
+        return this.enact;
+    }
+    
+    set do(value) {
+        this.enact = value;
+    }
+    
+    get undo() {
+        return this.counteract;
+    }
+    
+    set undo(value) {
+        this.counteract = value;
+    }
+
     // endregion Test definition, short names
 
-    // region Tuple state and dependencies
+    // region Def state
 
-    get isRunnable() {
+    get isRunnable() /* passed */ {
         let isRunnable
             = this.nature !== undefined
             && this.type !== undefined
@@ -174,32 +175,22 @@ export class TestDefinition {
     }
 
     get isStaticTest() /* passed */ {
-        let plainName = TestDefinition.plainNameOf(this.of);
+        let plainName = NameAnalyzer.plainNameOf(this.of);
 
-        let is = TypeAnalyzer.memberIsStatic(this.on, plainName);
-        let stated = this.andStringContains(TestDefinition.staticName);
+        let is = TypeAnalyzer.isStaticMember(this.on, plainName);
+        let stated = this.andStringContains(TestDef.staticName);
 
         return is || stated;
     }
     
     get isThrowTest() /* passed */ {
-        let is = this.andStringContains(TestDefinition.throwName);
+        let is = this.andStringContains(TestDef.throwName);
         return is;
     }
 
-    /* Needed externally, and dependency 
-       of all .and-based properties. */
-    andStringContains(keyword) /* passed */ {
-        let doesContain 
-            = typeof this.and === "string"
-            && this.and.includes(keyword);
-
-        return doesContain;
-    }
-
     get isConstructorTest() /* passed */ {
-        let plainTarget = TestDefinition.plainNameOf(this.of);
-        return plainTarget === TestDefinition.constructorName;
+        let plainTarget = NameAnalyzer.plainNameOf(this.of);
+        return plainTarget === TestDef.constructorName;
     }
 
     get isMethodTest() /* passed */ {
@@ -207,12 +198,11 @@ export class TestDefinition {
     }
 
     get isPropertyTest() /* passed */ {
-        let plainName = TestDefinition.plainNameOf(this.of);
+        let plainName = NameAnalyzer.plainNameOf(this.of);
         
         let isPropertyTest 
-            = this.of.startsWith(TestDefinition.dotOperator) 
-            || this.of.endsWith(TestDefinition.colonOperator) 
-            || TypeAnalyzer.memberIsProperty(this.on, plainName);
+            = NameAnalyzer.hasPropertySigil(this.of) 
+            || TypeAnalyzer.isPropertyMember(this.on, plainName);
         
         return isPropertyTest;
     }
@@ -237,121 +227,185 @@ export class TestDefinition {
         return false;
     }
 
-    // endregion Tuple state and dependencies
+    get doesHaveDoEarly() /* passed */ {
+        if (this.do === undefined) {
+            return false;
+        }
 
-    // endregion Properties
+        return TypeIdentifier.identify(this.do.early) === Types.isFunction;
+    }
+    
+    get doesHaveDoLate() /* passed */ {
+        if (this.do === undefined) {
+            return false;
+        }
+        
+        return TypeIdentifier.identify(this.do.late) === Types.isFunction;
+    }
+    
+    get doesHaveUndo() /* passed */ {
+        return TypeIdentifier.identify(this.undo) === Types.isFunction;
+    }
 
-    // region Initing, including constructor()
+    /* Used for grouping in output by method or 
+       prop name, with type sigil only once. */
+    get runName() /* passed */ {
+        let plain = NameAnalyzer.plainNameOf(this.of);
 
-    /* Constructor can't use param names like `for`, because when not .-prefixed, they are keywords. */
+        if (this.isMethodTest) {
+            return `${ plain }()`;
+        }
 
-    constructor(nature, type, spoofed, initors, settables, method, inputs, output, source, factors) {
-        this.nature = nature;        // .for 
-        this.type = type;            // .on 
-        this.spoofed = spoofed;      // .plus 
-        this.initors = initors;      // .with 
-        this.settables = settables;  // .amid 
-        this.method = method;        // .of 
-        this.inputs = inputs;        // .in 
-        this.output = output;        // .out 
-        this.source = source;        // .from 
-        this.factors = factors;      // .and 
+        if (this.isPropertyTest) {
+            return `.${ plain }`;
+        }
     }
 
-    copy() {
-        // Empty initial copy.
-        let copy = new TestDefinition();
+    // endregion Def state
 
-        let names = TestDefinition.longsByShort.values();
+    // endregion Properties
 
-        for (let name of names) {
-            copy[name] = TestDefinition.#copier.copy(this[name]);
-        }
-        
-        return copy;
+    // region Def state methods
+
+    /* Needed externally, and dependency 
+       of all .and-based properties. */
+    andStringContains(keyword) /* passed */ {
+        let doesContain 
+            = typeof this.and === "string"
+            && this.and.includes(keyword);
+
+        return doesContain;
     }
 
-    static fromNonceTuples(nonces) {
+    // endregion Def state methods
+
+    // region Initing, including constructor()
+
+    /* Constructor can't use parameter names like `for`: 
+       when not .-prefixed, they are purely keywords. */
+    constructor(nature, type, spoofed, initors, method, inputs, output, source, factors, enact, counteract) /* ok */ {
+        this.nature = nature;           // .for 
+        this.type = type;               // .on 
+        this.spoofed = spoofed;         // .plus 
+        this.initors = initors;         // .with 
+        this.method = method;           // .of 
+        this.inputs = inputs;           // .in 
+        this.output = output;           // .out 
+        this.source = source;           // .from 
+        this.factors = factors;         // .and 
+        this.enact = enact;             // .do 
+        this.counteract = counteract;   // .undo 
+    }
+
+    static fromNonceTuples(nonces) /* passed */ {
         // Throughput and output.
-        let full = new TestDefinition();
-        let tuples = [];
+        let full = new TestDef();
+        let defs = [];
 
         // Looping over all.
         for (let nonce of nonces) {
             // Get latest test definition.
-            let latest = TestDefinition.fromNonceTuple(nonce);
+            let latest = TestDef.fromNonceTuple(nonce);
 
             // Restarting test definitions when desired.
-            full = TestDefinition.maybeRestartFull(full, latest);
+            full = TestDef.maybeRestartFull(full, latest);
 
             // Merge any previous 
             // values into latest.
-            latest.combineWith(full);
+            TestDef.combine(latest, full);
 
             // Make latest the tuple for 
             // combining with next time.
             full = latest;
 
+            // Changes to the current def, rather than 
+            // a new one, should not result in a new def.
+            if (TestDef.isChangeOnlyNonce(nonce)) {
+                continue;
+            }
+
             // Add latest, if it's ready to run as a test.
             if (latest.isRunnable) {
-                tuples.push(latest);
+                defs.push(latest);
             }
         }
 
         // Back to caller.
-        return tuples;
+        return defs;
     }
 
-    static fromNonceTuple(nonce) {
+    /* Transfers properties in 'nonce' to a new TestDef 
+       if they match by either (first) short or long name.  
+       Unmatched props remain undefined on the TestDef. */
+    static fromNonceTuple(nonce) /* passed */ {
         // Empty, since properties can be set 
         // by either of two nonce naming styles.
-        let tuple = new TestDefinition();
+        let def = new TestDef();
 
-        let shortNames = TestDefinition.longsByShort.keys();
+        let shortNames = TestDef.longsByShort.keys();
 
         // Traversing matching pairs of names and applying 
         // whichever one is present as the tuple property;
         // if neither is present, the property is undefined.
         for (let shortName of shortNames) {
-            let longName = TestDefinition.longsByShort.get(shortName);
-            tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+            let longName = TestDef.longsByShort.get(shortName);
+            def[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
         }
 
         // Back to caller.
-        return tuple;
+        return def;
     }
 
     // region Dependencies of nonce-tuple initing methods
 
-    static maybeRestartFull(full, latest) {
+    /* Replaces some or all of the 'full' that gathers test 
+       props for reuse when targeting changes significantly 
+       in the middle of the collapsing-forward process. */
+    static maybeRestartFull(full, latest) /* passed */ {
         // When a (new) model class is named, 
         // wipe out all reused test values.
         if (latest.type !== undefined) {
-            full = new TestDefinition();
+            full = new TestDef();
         }
 
         // When a (new) model method is named, wipe out reused 
-        // test values except the general ones for its class.
+        // test values except the general ones for its class 
+        // and .nature, needed for collapsing forward.
         if (latest.method !== undefined) {
-            full = new TestDefinition(
-                full.nature, full.type,
-                full.spoofed, full.initors
-            );
+            full = TestDef.classOnlyDefFrom(full);
         }
 
         return full;
     }
 
-    combineWith(other) {
-        let shortNames = TestDefinition.longsByShort.keys();
+    static classOnlyDefFrom(original) /* passed */ {
+        let output = new TestDef();
+
+        output.type = original.type;
+        output.initors = original.initors;
+        output.spoofed = original.spoofed;
+
+        return output;
+    }
+
+    /* Replaces properties of the 'self' 
+       TestDef with any from 'other'. */
+    static combine(self, other) /* passed */ {
+        let shortNames = TestDef.longsByShort.keys();
 
         // Collapse properties forward.
         for (let shortName of shortNames) {
-            TestDefinition.combineValues(this, other, shortName);
+            TestDef.combineValues(self, other, shortName);
         }
     }
 
-    static combineValues(self, other, name) {
+    static isChangeOnlyNonce(nonce) /* passed */ {
+        return nonce.just !== undefined || nonce.only !== undefined;
+    }
+
+    /* Replaces the named property of 'self', if 
+       missing, with any new property of 'other'. */
+    static combineValues(self, other, name) /* passed */ {
         // Property may still end up undefined.
         if (self[name] === undefined) {
             self[name] = other[name];
@@ -362,12 +416,4 @@ export class TestDefinition {
 
     // endregion Initing, including constructor()
 
-    // region Other statics
-
-    static plainNameOf(name) /* passed */ {
-        let plain = name.replaceAll(TestDefinition.operatorsRegExp, "");
-        return plain;
-    }
-
-    // endregion Other statics
 }

package/system/TestFinder.js

@@ -2,13 +2,13 @@
 
 /* TestFinder is an ATestFinder that finds tests in the places identified in package.json. */
 
-import { ATestFinder } from "./ATestFinder.js";
-import { ATestSource } from "./ATestSource.js";
+import ATestFinder from "./ATestFinder.js";
+import ATestSource from "./ATestSource.js";
 import fs from "node:fs";
 import path from "node:path";
 import { minimatch } from "minimatch";
 
-export class TestFinder extends ATestFinder {
+export default class TestFinder extends ATestFinder {
     // region Definitions
 
     static NO_SUCH_FILE = "ENOENT";

package/system/TestFrame.js

@@ -1,95 +1,58 @@
 /**/
 
-import { TestStages } from "./TestStages.js";
+import TestStages from "./TestStages.js";
 
-export class TestFrame {
-    /* &cruft, when TestStages is ready, use it and its methods here */
-    
+export default class TestFrame {
     #stages;
 
-    constructor() {
+    constructor() /* ok */ {
         // A TestStages is inited for each test.
         this.#stages = new TestStages();
     }
     
-    testFrame(test) {
-        /* &cruft, removing logging after it's no longer needed */
-        // console.log(`cruft : a`);
-
+    run(test) /* passed */ {
         // Outer try for fails of groundwork requested.
         try {
-            // console.log(`cruft : b`);
-
-            // Spoofing, setting static properties, and so on.
+            // Spoofing and so on.
             this.#stages.anyPreTargetingGroundwork(test);
             
-            // console.log(`cruft : c`);
-
             // Target may be instance, prototype for constructors, the class 
             // itself for statics, or nonce for properties.  Sets test.target.
             this.#stages.setTarget(test);
             
-            // console.log(`cruft : d`);
-            
+            let target = this.#stages.supplyLocalTarget(test);
+
             // Method under test may be on instance, class, 
             // or nonce for properties.  Sets test.callable.
-            this.#stages.setLocalCallable(test);
+            let callable = this.#stages.supplyCallableName(test);
             
-            // console.log(`cruft : e`);
-            
-            // Setting instance properties and so on.
+            // Setting (spoofing) properties and so on.
             this.#stages.anyPostTargetingGroundwork(test);
             
-            // console.log(`cruft : f`);
-            
             // Inner try for fails of targeted code only.
             try {
-                // console.log(`cruft : g`);
-                
-                // console.log(`cruft : test.actual:`, test.actual);
-                // console.log(`cruft : test.target:`, test.target);
-                // console.log(`cruft : test.localCallable:`, test.localCallable);
-                // console.log(`cruft : test.in:`, test.in);
-            
                 // Tests usually look for this.
-                test.actual = test.target[test.localCallable](...test.in);
-                
-                // console.log(`cruft : test.actual:`, test.actual);
-                // console.log(`cruft : h`);
+                test.actual = target[callable](...test.in);
             }
             catch (thrown) {
-                // console.log(`cruft : i`);
-                
                 // Sometimes tests look for this.
                 test.thrown = thrown;
-                
-                // console.log(`cruft : j`);
             }
 
-            // console.log(`cruft : k`);
-
             // Sometimes tests look for results elsewhere. 
             this.#stages.anyModifyActual(test);
 
-            // console.log(`cruft : l`);
-
             // Actually testing the result.
             test.didPass = this.#stages.compareResults(test.output, test.actual);
-            
-            /* &cruft, remove this test-checking line when all tests pass */
-            // test.didPass = !test.didPass;
-
-            // console.log(`cruft : m`);
+        }
+        catch (thrown) {
+            /* Block needed, but no operations. */
         }
         finally {
-            // console.log(`cruft : n`);
-        
             // Undoing any groundwork changes made. 
-            this.#stages.anyGroundworkReversion(test);
-            
-            // console.log(`cruft : o`);
+            this.#stages.anyGroundworkReversal(test);
         }
         
-        // console.log(`cruft : p`);
+        // console.log(`cruft : q, outer try-catch : after`);
     }
 }

package/system/TestGroup.js

@@ -1,6 +1,6 @@
 /**/
 
-export class TestGroup {
+export default class TestGroup {
     // region Private fields
 
     #group;

package/system/TestResult.js

@@ -1,8 +1,8 @@
 /**/
 
-import { TotalDisplayer } from "./TotalDisplayer.js";
+import TotalDisplayer from "./TotalDisplayer.js";
 
-export class TestResult {
+export default class TestResult {
     // region Components
 
     #displayer;