risei 2.0.1 → 3.1.0

package/system/NameAnalyzer.js

@@ -1,26 +1,26 @@
-/**/
-
-export default class NameAnalyzer {
-    // region Definitions
-
-    static dotOperator = ".";
-    static colonOperator = ":";
-    static parensOperator = "()";
-    static operatorsRegExp = /\.|:|\(\)/g;
-
-    // endregion Definitions
-
-    static hasPropertySigil(name) /* passed */ {
-        return name.startsWith(NameAnalyzer.dotOperator) || name.endsWith(NameAnalyzer.colonOperator);
-    }
-
-    static hasMethodSigil(name) /* passed */ {
-        return name.endsWith(NameAnalyzer.parensOperator);
-    }
-
-    static plainNameOf(name) /* passed */ {
-        let plain = name.replaceAll(NameAnalyzer.operatorsRegExp, "");
-        return plain;
-    }
-}
-
+/**/
+
+export default class NameAnalyzer {
+    // region Definitions
+
+    static dotOperator = ".";
+    static colonOperator = ":";
+    static parensOperator = "()";
+    static operatorsRegExp = /\.|:|\(\)/g;
+
+    // endregion Definitions
+
+    static hasPropertySigil(name) /* passed */ {
+        return name.startsWith(NameAnalyzer.dotOperator) || name.endsWith(NameAnalyzer.colonOperator);
+    }
+
+    static hasMethodSigil(name) /* passed */ {
+        return name.endsWith(NameAnalyzer.parensOperator);
+    }
+
+    static plainNameOf(name) /* passed */ {
+        let plain = name.replaceAll(NameAnalyzer.operatorsRegExp, "");
+        return plain;
+    }
+}
+

package/system/ObjectAnalyzer.js

@@ -0,0 +1,36 @@
+/**/
+
+import TypeAnalyzer from "./TypeAnalyzer.js";
+
+export default class ObjectAnalyzer {
+    /* Retrieves names of all properties, both values 
+       and accessors, including all in superclasses. */
+    static allProperties(topic) /* passed */ {
+        let proto = Object.getPrototypeOf(topic);
+
+        let getters = [];
+
+        // Accessors, including in superclasses.
+        // Nonce object has no prototype / type.
+        if (proto !== null) {
+            let type = proto.constructor;
+            getters = TypeAnalyzer.allGetters(type);
+        }
+
+        let names = [];
+
+        // All value names, including inherited ones.
+        for (let name in topic) {
+            names.push(name);
+        }
+
+        // Concat good enough since sorting needed after anyway.
+        let output = names.concat(getters);
+
+        // Instead of mixed two sets in order coded, 
+        // accessors backwards up prototype chain.
+        output.sort();
+
+        return output;
+    }
+}

package/system/PropertySpoofer.js

@@ -52,7 +52,7 @@ export default class PropertySpoofer extends ASpoofingFixture {
     // endregion Properties
 
     constructor() {
-        super("PropertySpoofer", "Construction");
+        super();
     }
     
     /* Spoofs properties of test.target as defined in any test.plus. */

package/system/SpoofDef.js

@@ -2,6 +2,7 @@
 
 import TypeAnalyzer from "./TypeAnalyzer.js";
 import NameAnalyzer from "./NameAnalyzer.js";
+import TotalDisplayer from "./TotalDisplayer.js";
 
 /* Defines what is found in a spoof definition, typically as 
    a nonce object rather than an instance of this class. */
@@ -20,11 +21,6 @@ export default class SpoofDef {
         SpoofDef.#asNames
     ]);
     
-    /* &cruft, remove these after spoofing in .with and .in is removed */
-    /* Objects with either of these property names aren't 
-       converted to spoofDefs by from-nonce methods. */
-    static skipNames = [ "not", "skip" ];
-
     // endregion Static fields
 
     // region Public fields (long names)
@@ -135,14 +131,14 @@ export default class SpoofDef {
 
     // region Initing, including constructor() and statics
 
-    /* Constructor can't use param names like `of`, because when not .-prefixed, they are keywords. */
-
+    /* Long names used, just in case. */
     constructor(target, method, output) /* passed */ {
         this.target = target;
         this.method = method;
         this.output = output;
     }
 
+    /* Arg 'type' should be test.type if present. */
     static fromNonceTuples(nonces, type) /* passed */ {
         // Throughput and output.
         let full = new SpoofDef();
@@ -159,82 +155,102 @@ export default class SpoofDef {
         return output;
     }
     
+    /* Arg 'type' should be test.type if present. */
     static fromNonceTuple(nonce, type) /* passed */ {
-        /* No spoof-def to output. */
+        // No spoof-def to output.
         if (SpoofDef.isNotASpoof(nonce)) {
             return [ ];
         }
 
-        // Empty, since properties can be set 
-        // by either of two nonce naming styles.
+        let defs = [ ];
+
+        // Nonce defines one spoof.
+        if (SpoofDef.#isMonoSpoof(nonce)) {
+            let def = SpoofDef.#fromMonoNonce(nonce, type);
+            defs.push(def);
+        }
+
+        // Nonce defines more than one spoof: Recursion.
+        if (SpoofDef.#isPolySpoof(nonce)) {
+            let locals = SpoofDef.#fromPolyNonce(nonce, type);
+            defs.push(...locals);
+        }
+
+        return defs;
+    }
+
+    // region Dependencies of nonce-tuple initing methods
+
+    static #isMonoSpoof(nonce) /* verified */ {
+        return SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
+    }
+
+    static #isPolySpoof(nonce) /* verified */ {
+        return !SpoofDef.#isMonoSpoof(nonce);
+    }
+
+    /* Arg 'type' should be test.type if present. */
+    static #fromMonoNonce(nonce, type) /* verified */ {
+        // Empty, since each prop can 
+        // have either of two names.
         let def = new SpoofDef();
 
         let shortNames = SpoofDef.#longsByShort.keys();
 
-        /* &cruft, maybe refactor to put property-setting loop in its own method, and possibly 
-                   recurse internally using it without inner arrays, for a cleaner algorithm */
-
-        // Traversing matching pairs of names and applying 
-        // whichever one is present as the tuple property;
+        // Traversing name pairs to use whichever one is present; 
         // if neither is present, the property is undefined.
         for (let shortName of shortNames) {
             let longName = SpoofDef.#longsByShort.get(shortName);
-            def[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
+
+            def[shortName] 
+                = nonce[shortName] !== undefined 
+                ? nonce[shortName] 
+                : nonce[longName];
         }
 
-        // No nested partial spoof-defs 
-        // (mono-spoof) is most likely.
-        let defs = [ def ];
+        // Adding test target's type, if no type provided.
+        if (def.target === undefined) {
+            def.target = type;
+        }
 
-        // Recursion to handle nested partial spoof-defs (poly-spoofs).
-        if (def.method === undefined && Array.isArray(def.output)) {
-            let locals = [ ];
+        return def;
+    }
 
-            for (let ofAsPair of def.output) {
-                let localOf = ofAsPair.of !== undefined ? ofAsPair.of : ofAsPair.method;
-                let localAs = ofAsPair.as !== undefined ? ofAsPair.as : ofAsPair.output;
+    /* Arg 'type' should be test.type if present. */
+    static #fromPolyNonce(nonce, type) /* verified */ {
+        let defs = [ ];
 
-                let passer = SpoofDef.fromNonceTuple({ on: def.target, of: localOf, as: localAs });
-                locals.push(passer[0]);
-            }
+        // Poly-nonce's .on applies to all its partial spoofs.
+        let on = nonce.on !== undefined ? nonce.on : nonce.target;
 
-            // Replace default spoof 
-            // with real poly-spoofs.
-            defs = locals;
-        }
+        // Poly-nonce's .as is an array of partial-spoof nonces.
+        let pairs = nonce.as !== undefined ? nonce.as : nonce.output;
 
-        // All defs need a type / target class.
-        SpoofDef.#setAnyMissingTypes(defs, type);
+        // Traversing partial-spoof nonces (.of and .as only).
+        for (let pair of pairs) {
+            // Either name (or neither) may exist on nonce partial.
+            let of = pair.of !== undefined ? pair.of : pair.method;
+            let as = pair.as !== undefined ? pair.as : pair.output;
+
+            // Only one level of recursion.
+            let passer = SpoofDef.#fromMonoNonce({ on, of, as }, type);
+
+            defs.push(passer);
+        }
 
-        // Back to caller.
         return defs;
     }
 
-    // region Dependencies of nonce-tuple initing methods
-
     static #hasEitherName(nonce, names) /* verified */ {
         let hasEither = false;
 
         for (let name of names) {
-            hasEither ||= SpoofDef.#hasName(nonce, name);
+            hasEither ||= nonce[name] !== undefined;
         }
         
         return hasEither;
     }
 
-    static #hasName(nonce, name) /* verified */ {
-        return nonce[name] !== undefined;
-    }
-
-    static #setAnyMissingTypes(defs, type) /* verified */ {
-        // Adding test target's type, if no type provided.
-        for (let def of defs) {
-            if (def.target === undefined) {
-                def.target = type;
-            }
-        }
-    }
-
     // endregion Dependencies of nonce-tuple initing methods
 
     // endregion Initing, including constructor() and statics
@@ -242,19 +258,13 @@ export default class SpoofDef {
     // region Overrides and dependencies
 
     toString() /* passed */ {
-        let text = `SpoofDefinition:{ target:${ this.#asRawOrString(this.target) }, `
-            + `method:${ this.#asRawOrString(this.method) }, `
-            + `output:${ this.#asRawOrString(this.output) } }`;
+        let displayer = new TotalDisplayer();
+
+        let text = `SpoofDef{ on:${ displayer.display(this.target) }, `
+            + `of:${ displayer.display(this.method) }, `
+            + `as:${ displayer.display(this.output) } }`;
         return text;
     }
-    
-    #asRawOrString(value) /* verified */ {
-        if (typeof value === "string") {
-            return `"${ value }"`;
-        }
-        
-        return value;
-    }
-    
+
     // endregion Overrides and dependencies
 }

package/system/TerminalReporter.js

@@ -1,8 +1,8 @@
 /**/
 
-/* TerminalReporter is an ATestReporter that sends each result to the terminal / console for display. */
+/* TerminalReporter displays each test result in the terminal / console window. */
 
-import ATestReporter from "./ATestReporter.js";
+import Moment from "./Moment.js";
 import TestGroup from "./TestGroup.js";
 import ClassTestGroup from "./ClassTestGroup.js";
 import MethodTestGroup from "./MethodTestGroup.js";
@@ -11,8 +11,12 @@ import TestSummary from "./TestSummary.js";
 
 import chalk from "chalk";
 
-export default class TerminalReporter extends ATestReporter {
-    // region Private fields
+export default class TerminalReporter {
+    // region Fields
+
+    /* Display styles for the start title and other general needs. */
+    #title = chalk.hex("FFFFFF").bgHex("191970").bold;
+    #fails = chalk.hex("000000").bgHex("FFD700").bold;
 
     /* Foreground-colors using dependency calls and hex. */
     #trueWhite = chalk.hex("FFFFFF");
@@ -31,22 +35,53 @@ export default class TerminalReporter extends ATestReporter {
     #methodGroup = this.#trueWhite.bgHex(this.#aqua).bold;
     #passed = this.#trueBlack.bgHex(this.#paleGreen);
     #failed = this.#trueBlack.bgHex(this.#paleRed);
+    #problems = chalk.hex("000000").bgHex("FFD700").bold;
+
     #passedSummary = this.#trueBlack.bgHex(this.#paleGreen).bold;
     #failedSummary = this.#trueBlack.bgHex(this.#paleRed).bold;
     #summary = chalk.hex("000080").bgHex("FAFAD2").bold;
 
+
     // Count of characters used for indent 
     // and text to the left of each test.
     #preUsedWidth = 20;
 
-    // endregion PrivateFields
+    // endregion Fields
+
+    reportTitle() {
+        // This moment, ready for use in title.
+        let now = new Date();
+        now = new Moment(now);
+
+        // Top of screen and leading color stripe.
+        console.clear();
+        console.log();
+        console.log(this.#title(this.#wide()));
+
+        // Actually reporting title.
+        console.log(this.#title(this.#wide(` Risei tests run on ${ now.asReadable() } local time.`)));
+
+        // Trailing color stripe and blank line.
+        console.log(this.#title(this.#wide()));    
+        console.log();
+    }
+
+    // region Dependencies of reportTitle()
+
+    /* Styling for color stripes. */
+    #wide(text) { 
+        let width = process.stdout.columns;
+        text = text || "";
+
+        return text.padEnd(width, "\u00A0");
+    };
 
-    // region ATestReporter
+    // endregion Dependencies of reportTitle()
 
     reportNext(result) {
         // The next result introduces a group of tests.
         if (result instanceof TestGroup) {
-            this.reportGroup(result);
+            this.#reportGroup(result);
             return;
         }
 
@@ -58,12 +93,14 @@ export default class TerminalReporter extends ATestReporter {
 
         // The next result is the summary of all tests.
         if (result instanceof TestSummary) {
-            this.reportSummary(result);
+            this.#reportSummary(result);
             return;
         }
     }
 
-    reportGroup(result) {
+    // region Direct dependencies of reportNext(), except summary
+
+    #reportGroup(result) {
         if (result instanceof ClassTestGroup) {
             console.log(this.#classGroup(` ${ result.group }: `));
         }
@@ -73,32 +110,44 @@ export default class TerminalReporter extends ATestReporter {
         }
     }
 
-    // region Private dependencies of reportNext()
-
     #reportTestResult(result) {
+        if (result.doesHaveThrow) {
+            this.#reportThrew(result.anyThrow.stack);
+        }
+
+        if (result.doesHaveTrouble) {
+            this.#reportThrew(result.anyTrouble.stack);
+        }
+
         if (result.didPass) {
-            this.reportPassed(result);
+            this.#reportPassed(result);
         }
 
         if (!result.didPass) {
-            this.reportFailed(result);
+            this.#reportFailed(result);
         }
     }
 
-    // endregion Private dependencies of reportNext()
+    // endregion Direct dependencies of reportNext(), except summary
+
+    // region Direct dependencies of #reportTestResult()
+
+    #reportThrew(threw) {
+        console.log(this.#problems(threw));
+    }
 
-    reportPassed(result) {
+    #reportPassed(result) {
         this.#reportOneTestResult(result, "Passed", this.#passed);
     }
 
-    reportFailed(result) {
+    #reportFailed(result) {
         this.#reportOneTestResult(result, "Failed", this.#failed);
     }
 
-    // region Private dependencies of reportPassed() and reportFailed()
+    // endregion Direct dependencies of #reportTestResult()
+
+    // region Dependencies of #reportPassed() and #reportFailed()
 
-    /* &cruft, changes here / in dependencies 
-       for better splitting to multiple lines */
     #reportOneTestResult(result, net, styler) {
         let { lineOne, lineTwo, lineThree, lineFour } = this.#calculateResultDisplay(result);
 
@@ -166,7 +215,7 @@ export default class TerminalReporter extends ATestReporter {
         return this.#oneLineTactic(identityText, inputsText, expectedText, actualText);
     }
 
-    // region Private dependencies of #calculateResultDisplay()
+    // region Dependencies of #calculateResultDisplay()
 
     #fourLineTactic(identityText, inputsText, expectedText, actualText) {
         // Each line on its own.
@@ -218,13 +267,17 @@ export default class TerminalReporter extends ATestReporter {
         return { lineOne, lineTwo, lineThree, lineFour };
     }
 
-    // endregion Private dependencies of #calculateResultDisplay()
+    // endregion Dependencies of #calculateResultDisplay()
+
+    // endregion Dependencies of #reportPassed() and #reportFailed()
 
-    // endregion Private dependencies of reportPassed() and reportFailed()
+    // region Summary dependency of reportNext()
 
-    reportSummary(summary) {
+    #reportSummary(summary) {
         console.log();
 
+        /* Actual summary. */
+
         if (summary.anyWereRun) {
             if (summary.allDidPass) {
                 console.log(this.#passedSummary(this.#toFullWidth(" Test run succeeded.")));
@@ -235,7 +288,24 @@ export default class TerminalReporter extends ATestReporter {
         }
 
         console.log(this.#summary(this.#toFullWidth(` ${ summary.summary }`)));
-    }
+
+        /* Post-summary reporting of unsought throws. */
+
+        if (summary.anyThrows.length !== 0) {
+            console.log();
+            console.log(this.#problems(summary.anyThrows.join("\n")));
+        }
+
+        // And/or reporting of outer-scope throws.
+        if (summary.anyTroubles.length !== 0) {
+            console.log();
+            console.log(this.#problems(summary.anyTroubles.join("\n")));
+        }
+   }
+
+    // endregion Summary dependency of reportNext()
+
+    // region Dependencies of #reportSummary()
 
     #toFullWidth(text) {
         text = text || "";
@@ -244,6 +314,13 @@ export default class TerminalReporter extends ATestReporter {
         return text.padEnd(width, "\u00A0");
     }
 
-    // endregion ATestReporter
+    // endregion Dependencies of #reportSummary()
 
+    blankLine() {
+        console.log();
+    }
+
+    reportLoadFail(fail) {
+        console.log(this.#fails(this.#wide(` ${ fail }`)));
+    }
 }