risei 1.3.4 → 2.0.1

package/system/SpoofDef.js

@@ -0,0 +1,260 @@
+/**/
+
+import TypeAnalyzer from "./TypeAnalyzer.js";
+import NameAnalyzer from "./NameAnalyzer.js";
+
+/* Defines what is found in a spoof definition, typically as 
+   a nonce object rather than an instance of this class. */
+
+export default class SpoofDef {
+    // region Static fields
+
+    /* Properties can have short or long names. */
+    static #onNames = [ "on", "target" ];
+    static #ofNames = [ "of", "method" ];
+    static #asNames = [ "as", "output" ];
+
+    static #longsByShort = new Map([
+        SpoofDef.#onNames,
+        SpoofDef.#ofNames,
+        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)
+
+    /* These long names are clearer and match the constructor's parameter names. */
+
+    /* The test-definition field names use the longer, possibly clearer forms.  
+       Equivalent short-name and long-name properties use the same fields. */
+
+    target;
+    method;
+    output;
+
+    // endregion Public fields (long names)
+
+    // region Properties
+
+    // region Spoof definition, short names
+
+    /* These short names make JSON-like definitions easier. */
+
+    get on() {
+        return this.target;
+    }
+
+    set on(value) {
+        this.target = value;
+    }
+
+    get of() {
+        return this.method;
+    }
+
+    set of(value) {
+        this.method = value;
+    }
+
+    get as() {
+        return this.output;
+    }
+
+    set as(value) {
+        this.output = value;
+    }
+
+    // endregion Spoof definition, short names
+
+    // region Def state
+
+    /* Returns true if arg doesn't provide enough to spoof with. */
+    static isNotASpoof(nonce) /* passed */ {
+        return !SpoofDef.isASpoof(nonce);
+    }
+
+    /* Returns true if arg provides enough to spoof with. */
+    static isASpoof(nonce) /* passed */ {
+        /* Any nonce that is null or undefined is not a SpoofDef. */
+        if (nonce === undefined || nonce === null) {
+            return false;
+        }
+        
+        let hasAnOf = SpoofDef.#hasEitherName(nonce, SpoofDef.#ofNames);
+        let hasAnAs = SpoofDef.#hasEitherName(nonce, SpoofDef.#asNames);
+
+        /* Any nonce with at least an .of or an .as is a SpoofDef. */
+        return hasAnOf || hasAnAs;
+    }
+
+    get isMethodSpoof() /* passed */ {
+        if (this.target === undefined) {
+            throw new Error("No .on / .target present.  It must be set for .isMethodSpoof to work.");
+        }
+
+        let plainName = NameAnalyzer.plainNameOf(this.method);
+
+        if (NameAnalyzer.hasPropertySigil(this.method)) {
+            return false;
+        }
+
+        let isMethod 
+            = NameAnalyzer.hasMethodSigil(this.method) 
+            || TypeAnalyzer.isMethodMember(this.target, plainName);
+
+        return isMethod;
+    }
+
+    get isPropertySpoof() /* passed */ {
+        if (this.target === undefined) {
+            throw new Error("No .on / .target present.  It must be set for .isPropertySpoof to work.");
+        }
+
+        let plainName = NameAnalyzer.plainNameOf(this.method);
+
+        if (NameAnalyzer.hasMethodSigil(this.method)) {
+            return false;
+        }
+
+        let isProperty 
+            = NameAnalyzer.hasPropertySigil(this.method) 
+            || TypeAnalyzer.isPropertyMember(this.target, plainName);
+
+        return isProperty;
+    }
+
+    // endregion Def state
+
+    // endregion Properties
+
+    // region Initing, including constructor() and statics
+
+    /* Constructor can't use param names like `of`, because when not .-prefixed, they are keywords. */
+
+    constructor(target, method, output) /* passed */ {
+        this.target = target;
+        this.method = method;
+        this.output = output;
+    }
+
+    static fromNonceTuples(nonces, type) /* passed */ {
+        // Throughput and output.
+        let full = new SpoofDef();
+        let output = [ ];
+
+        // Looping over all.
+        for (let nonce of nonces) {
+            // Get latest spoof definition/s and retain for output.
+            let latests = SpoofDef.fromNonceTuple(nonce, type);
+            output.push(...latests);
+        }
+
+        // Back to caller.
+        return output;
+    }
+    
+    static fromNonceTuple(nonce, type) /* passed */ {
+        /* No spoof-def to output. */
+        if (SpoofDef.isNotASpoof(nonce)) {
+            return [ ];
+        }
+
+        // Empty, since properties can be set 
+        // by either of two nonce naming styles.
+        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;
+        // 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];
+        }
+
+        // No nested partial spoof-defs 
+        // (mono-spoof) is most likely.
+        let defs = [ def ];
+
+        // Recursion to handle nested partial spoof-defs (poly-spoofs).
+        if (def.method === undefined && Array.isArray(def.output)) {
+            let locals = [ ];
+
+            for (let ofAsPair of def.output) {
+                let localOf = ofAsPair.of !== undefined ? ofAsPair.of : ofAsPair.method;
+                let localAs = ofAsPair.as !== undefined ? ofAsPair.as : ofAsPair.output;
+
+                let passer = SpoofDef.fromNonceTuple({ on: def.target, of: localOf, as: localAs });
+                locals.push(passer[0]);
+            }
+
+            // Replace default spoof 
+            // with real poly-spoofs.
+            defs = locals;
+        }
+
+        // All defs need a type / target class.
+        SpoofDef.#setAnyMissingTypes(defs, type);
+
+        // 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);
+        }
+        
+        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
+
+    // region Overrides and dependencies
+
+    toString() /* passed */ {
+        let text = `SpoofDefinition:{ target:${ this.#asRawOrString(this.target) }, `
+            + `method:${ this.#asRawOrString(this.method) }, `
+            + `output:${ this.#asRawOrString(this.output) } }`;
+        return text;
+    }
+    
+    #asRawOrString(value) /* verified */ {
+        if (typeof value === "string") {
+            return `"${ value }"`;
+        }
+        
+        return value;
+    }
+    
+    // endregion Overrides and dependencies
+}

package/system/TerminalReporter.js

@@ -2,16 +2,16 @@
 
 /* TerminalReporter is an ATestReporter that sends each result to the terminal / console for display. */
 
-import { ATestReporter } from "./ATestReporter.js";
-import { TestGroup } from "./TestGroup.js";
-import { ClassTestGroup } from "./ClassTestGroup.js";
-import { MethodTestGroup } from "./MethodTestGroup.js";
-import { TestResult } from "./TestResult.js";
-import { TestSummary } from "./TestSummary.js";
+import ATestReporter from "./ATestReporter.js";
+import TestGroup from "./TestGroup.js";
+import ClassTestGroup from "./ClassTestGroup.js";
+import MethodTestGroup from "./MethodTestGroup.js";
+import TestResult from "./TestResult.js";
+import TestSummary from "./TestSummary.js";
 
 import chalk from "chalk";
 
-export class TerminalReporter extends ATestReporter {
+export default class TerminalReporter extends ATestReporter {
     // region Private fields
 
     /* Foreground-colors using dependency calls and hex. */
@@ -69,7 +69,7 @@ export class TerminalReporter extends ATestReporter {
         }
 
         if (result instanceof MethodTestGroup) {
-            console.log("   " + this.#methodGroup(` ${ result.group }(): `));
+            console.log("   " + this.#methodGroup(` ${ result.group }: `));
         }
     }