risei 1.3.4 → 2.0.0

package/xternal-tests/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "mocha-tests",
+  "version": "1.0.0",
+  "type": "module",
+  "dependencies": {
+  }
+}

package/system/AComparer.js

@@ -1,9 +0,0 @@
-/**/
-
-/* Defines operations that a comparer must implement. */
-
-export class AComparer {
-    compare(expected, actual) {
-        throw new Error("Implement compare() on a subclass of AComparer.");
-    }
-}

package/system/ATestFixture.js

@@ -1,44 +0,0 @@
-/**/
-
-export class ATestFixture {
-    // region Private fields
-
-    #name;
-    #kind;
-    #fixture;
-    
-    // endregion Private fields
-
-    // region Properties
-
-    get name() {
-        return this.#name;
-    }
-
-    set name(value) {
-        this.#name = value;
-    }
-
-    get kind() {
-        return this.#kind;
-    }
-
-    set kind(value) {
-        this.#kind = value;
-    }
-
-    get fixture() {
-        return this.#fixture;
-    }
-
-    set fixture(value) {
-        this.#fixture = value;
-    }
-
-    // endregion Properties
-
-    constructor(name, kind) {
-        this.#name = name;
-        this.#kind = kind;
-    }
-}

package/system/ClassPropertySpoofer.js

@@ -1,185 +0,0 @@
-/**/
-
-import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofDefinition } from "./SpoofDefinition.js";
-import { TypeAnalyzer } from "./TypeAnalyzer.js";
-
-/* &cruft, implement this under test so that anything that can be spoofed 
-           from the class level is spoofed, but not expecting it to get 
-           absolutely everything, and supporting poly-spoofing syntax */
-export class ClassPropertySpoofer extends ASpoofingFixture {
-    /* Algorithm:  Forward method spoof() looks at spoof definitions in .plus and applies them 
-                   to each class' prototypes after first saving the original member definitions.
-                   Reverse method unspoof() restores each original member definition.
-                   Fundamentally different from what ObjectMethodSpoofer does. */
-
-    // region Private fields
-
-    #spoofsByClass = new Map();
-    #originalsByClass = new Map();
-
-    // endregion Private fields
-
-    // region Properties
-
-    get spoofsByClass() {
-        return this.#spoofsByClass;
-    }
-
-    set spoofsByClass(value) {
-        this.#spoofsByClass = value;
-    }
-
-    get originalsByClass() {
-        return this.#originalsByClass;
-    }
-
-    set originalsByClass(value) {
-        this.#originalsByClass = value;
-    }
-
-    // endregion Properties
-
-    constructor() {
-        super("ClassPropertySpoofer", "Construction");
-    }
-    
-    /* Spoofs methods of classes as defined in nonce 
-       spoof-tuple definitions in any test.plus. */
-    spoof(test) {
-        // Localizing.
-        let type = test.on;
-        let spoofNonces = test.plus;
-        
-        // Spoofing definitions are always in an array.
-        if (!Array.isArray(spoofNonces)) {
-            return;
-        }
-    
-        // Converting to scope object type.
-        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
-        
-        // Storing spoofing definitions.
-        this.#retainSpoofsByClass(type, spoofDefinitions);
-        
-        // Storing originals for restoring later.
-        this.#reserveOriginalsByClass();
-        
-        // Actually spoofing.
-        this.#spoofMembersByClass();
-    }
-
-    // region Dependencies of spoof()
-
-    #retainSpoofsByClass(type, spoofDefinitions) {
-        // Map of Maps: by type, then by method.
-        for (let tuple of spoofDefinitions) {
-            // If no .target, use `type`. 
-            if (!tuple.target) {
-                tuple.target = type;
-            }
-            
-            let spoofsByTarget = this.#supplyMemberMap(this.#spoofsByClass, tuple.target);
-            
-            // A single-method spoof is set for later use.
-            if (tuple.method) {
-                spoofsByTarget.set(tuple.method, tuple.output);
-                continue;
-            }
-            
-            // Two or more method spoofs are set for later use.
-            if (tuple.output) {
-                let ofAsPairs = tuple.output;
-                
-                for (let pair of ofAsPairs) {
-                    spoofsByTarget.set(pair.of, pair.as);
-                }
-                
-                continue;
-            }
-        }
-    }
-    
-    #reserveOriginalsByClass() {
-        /* Any spoofing of multiple methods on each class has already been 
-           split up into Map elements, so this code can use those naively. */
-    
-        let types = this.#spoofsByClass.keys();
-        
-        // For each class.
-        for (let type of types) {
-            let originalsByTarget = this.#supplyMemberMap(this.#originalsByClass, type);
-            
-            let spoofsByTarget = this.#spoofsByClass.get(type);
-            let names = spoofsByTarget.keys();
-            
-            // Saving originals in the Map for later.
-            for (let name of names) {
-                let original = type.prototype[name];
-                originalsByTarget.set(name, original);
-            }
-        }
-    }
-
-    /* Dependency of #retainSpoofsByClass() 
-       and #reserveOriginalsByClass(). */
-    #supplyMemberMap(source, target) {
-        let mapForType = source.get(target);
-        
-        if (!mapForType) {
-            mapForType = new Map();
-            source.set(target, mapForType);
-        }
-        
-        return mapForType;
-    }
-
-    #spoofMembersByClass() {
-        /* Any spoofing of multiple methods on each class has already been 
-           split up into Map elements, so this code can use those naively. */
-
-        let types = this.#spoofsByClass.keys();
-    
-        // For each class.
-        for (let type of types) {
-            let spoofsByTarget = this.#spoofsByClass.get(type);
-            let names = spoofsByTarget.keys();
-
-            // Actually spoofing, one by one.
-            for (let name of names) {
-                let spoofSource = spoofsByTarget.get(name);
-                let spoof = super.spoofMethod(spoofSource);
-                type.prototype[name] = spoof;
-            }
-        }
-    }
-
-    // endregion Dependencies of spoof()
-
-    // Spoofed methods on any targeted classes 
-    // are restored to their original forms.
-    unspoof() {
-        let types = this.#originalsByClass.keys();
-        
-        // For each class.
-        for (let target of types) {
-            let prototype = target.prototype;
-            
-            let originalsByTarget = this.#originalsByClass.get(target);
-            let names = originalsByTarget.keys();
-            
-            // Actually restoring, one by one.
-            for (let name of names) {
-                let original = originalsByTarget.get(name);
-                target.prototype[name] = original;
-            }
-        }
-    }
-
-    // Removes definitions, useful if this instance is reused, 
-    // or else they might be applied when they shouldn't be.
-    removeDefinitions() {
-        this.#spoofsByClass.clear();
-        this.#originalsByClass.clear();
-    }
-}

package/system/ObjectMethodSpoofer.js

@@ -1,58 +0,0 @@
-/* */
-
-import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofDefinition } from "./SpoofDefinition.js";
-
-export class ObjectMethodSpoofer extends ASpoofingFixture {
-    /* Algorithm:  Forward method spoof() looks at a test's .with and .in, and replaces entire objects 
-                   in each with spoofed object trees, if the originals are spoof definitions.
-                   No reverse unspoofing method is needed, since objects are nonces tossed after tests.
-                   Fundamentally different from much of what ClassMethodSpoofer does. */
-
-    constructor() {
-        super("ObjectMethodSpoofer", "Construction");
-    }
-    
-    /* Spoofs methods of any objects in test.with and test.in 
-       for which nonce spoof-tuple definitions are provided. */
-    spoof(test) {
-        // These array test aspects may contain object-spoof definitions.
-        let topics = [ test.with, test.in ];
-        
-        // Spoofing each array of test-aspect elements.
-        for (let topic of topics) {
-            // Replacing whole element with spoof or with unchanged self.
-            for (let at = 0; at < topic.length; at++) {
-                let target = topic[at];
-                topic[at] = this.spoofTarget(target);
-            }
-        }
-    }
-
-    spoofTarget(target) {
-        // Non-spoof targets are returned unchanged.
-        if (SpoofDefinition.isNotASpoof(target)) {
-            return target;
-        }
-
-        // Spoof definition targets are converted.
-        let tuple = SpoofDefinition.fromNonceTuple(target);
-        let ofAsPairs = this.#supplySpoofPairs(tuple);
-        
-        // Returning object with one or more spoofed members.
-        let spoofedTarget = super.spoofObjectTree(ofAsPairs);
-        return spoofedTarget;
-    }
-
-    #supplySpoofPairs(tuple) {
-        // Single-spoof output.
-        let ofAsPairs = [{ of: tuple.method, as: tuple.output }];
-
-        // Poly-spoof output.
-        if (!tuple.method) {
-            ofAsPairs = tuple.output;
-        }
-        
-        return ofAsPairs;
-    }
-}

package/system/ObjectPropertySpoofer.js

@@ -1,136 +0,0 @@
-/**/
-
-import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofDefinition } from "./SpoofDefinition.js";
-import { TypeAnalyzer } from "./TypeAnalyzer.js";
-
-export class ObjectPropertySpoofer extends ASpoofingFixture {
-    /* Algorithm:  Forward method spoof() looks at property spoof definitions in .plus 
-                   and first saves the original values, then applies the spoofed ones.
-                   Reverse method unspoof() restores each original property value.
-                   Fundamentally different from what ObjectMethodSpoofer does. */
-
-    // region Private fields
-
-    // Spoofed and original property values.
-    #settables = [ ];
-    #unsettables = [ ];
-
-    // endregion Private fields
-
-    // region Properties
-
-    get settables() {
-        return this.#settables;
-    }
-
-    set settables(value) {
-        this.#settables = value;
-    }
-
-    get unsettables() {
-        return this.#unsettables;
-    }
-
-    set unsettables(value) {
-        this.#unsettables = value;
-    }
-
-    // endregion Properties
-
-    constructor() {
-        super("ObjectPropertySpoofer", "Construction");
-    }
-    
-    /* Spoofs properties of test.target as defined in any test.plus. */
-    spoof(test) {
-        // Localizing.
-        let target = test.target;
-        let spoofNonces = test.plus;
-
-        // Spoofing definitions are always in an array.
-        if (!Array.isArray(spoofNonces)) {
-            return;
-        }
-    
-        // Converting to scope object type.
-        let spoofDefinitions = SpoofDefinition.fromNonceTuples(spoofNonces);
-
-        // Working only with property spoofs.
-        let propertySpoofs = Array.from(spoofDefinitions)
-            .filter(spoof => TypeAnalyzer.memberIsProperty(test.on, spoof.of));
-
-        // Storing new values for setting.
-        this.#settables = propertySpoofs;
-
-        // Storing original values for restoring later.
-        this.#unsettables = this.#anyOriginalPropertyGetting(target, this.#settables);
-
-        // Actually spoofing with new values.
-        this.#anyPropertySetting(target, this.#settables);
-    }
-
-    // Spoofed methods on any targeted classes 
-    // are restored to their original forms.
-    unspoof() {
-        this.#anyPropertyUnsetting(this.target, this.#unsettables);
-    }
-
-    // region Dependencies of spoof()
-
-    #anyOriginalPropertyGetting(target, settables) {
-        if (!Array.isArray(settables)) {
-            return;
-        }
-    
-        let unsettables = [ ];
-        
-        for (let settable of settables) {
-            // Not a setter tuple if no settable value.
-            if (settable.of === undefined) {
-                continue;
-            }
-            
-            // Retaining original.
-            let original = target[settable.of];
-            let unsettable = { of: settable.of, as: original };
-
-            unsettables.push(unsettable);
-        }
-        
-        return unsettables;
-    }
-
-    // endregion Dependencies of spoof()
-    
-    // region Dependencies of unspoof()
-
-    #anyPropertyUnsetting(target, unsettables) {
-        // Unsetting is the same as setting, 
-        // but with tuples of original values.
-        return this.#anyPropertySetting(target, unsettables);
-    }
-
-    // endregion Dependencies of unspoof()
-
-    // region Dependencies of both spoof() and unspoof()
-
-    #anyPropertySetting(target, settables) {
-        // No properties to set.
-        if (!Array.isArray(settables)) {
-            return;
-        }
-    
-        for (let settable of settables) {
-            // Not a setter tuple if no settable value.
-            if (settable.of === undefined) {
-                continue;
-            }
-
-            // Actually setting property.
-            target[settable.of] = settable.as;
-        }
-    }
-
-    // endregion Dependencies of both spoof() and unspoof()
-}

package/system/SpoofDefinition.js

@@ -1,243 +0,0 @@
-/**/
-
-import { TypeAnalyzer } from "./TypeAnalyzer.js";
-
-/* Defines what is found in a spoof-definition tuple (SDT).  Actual SDTs don't need to be instances of this class. */
-
-export class SpoofDefinition {
-    // region Static fields
-
-    /* Properties can have short or long names. */
-    static #longsByShort = new Map([
-        [ "on", "target" ],
-        [ "of", "method" ],
-        [ "as", "output" ],
-    ]);
-    
-    /* Objects with either of these property names aren't 
-       converted to SpoofDefinitions 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 Tuple state
-
-    /* Returns true if instance provides enough to spoof with.
-       A spoof must define at least either a method to spoof, or an output 
-       containing an array of methods to spoof, with optional outputs.
-       See .notASpoof() for a contrasting condition. */
-    isSpoofable() /* passed */ {
-        let isSpoofable 
-            = this.method !== undefined 
-            || this.output !== undefined; 
-        
-        return isSpoofable;
-    }
-    
-    isPropertySpoof() /* passed */ {
-        return TypeAnalyzer.memberIsProperty(this.target, this.method);
-    }
-
-    // endregion Tuple state
-
-    // endregion Properties
-
-    // region Initing, including constructor()
-
-    /* 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) {
-        // Throughput and output.
-        let full = new SpoofDefinition();
-        let output = [];
-
-        // Looping over all.
-        for (let nonce of nonces) {
-            // Don't convert non-tuples, but output 
-            // them unchanged for the caller.
-            if (SpoofDefinition.isNotASpoof(nonce)) {
-                output.push(nonce);
-                continue;
-            }
-        
-            // Get latest spoof definition.
-            let latest = SpoofDefinition.fromNonceTuple(nonce);
-
-            // Restarting spoof definitions when desired.
-            full = SpoofDefinition.maybeRestartFull(full, latest);
-
-            // Merge any previous 
-            // values into latest.
-            latest.combineWith(full);
-
-            // Make latest the tuple for 
-            // combining with next time.
-            full = latest;
-
-            // Add latest only if it's 
-            // ready to use to spoof.
-            if (latest.isSpoofable) {
-                output.push(latest);
-            }
-        }
-
-        // Back to caller.
-        return output;
-    }
-    
-    /* Returns true if arg should not be used for spoofing.
-       See isSpoofable() for a contrasting condition. */
-    static isNotASpoof(nonce) /* passed */ {
-        /* Any nonce that is null or undefined is not a SpoofDefinition. */
-        if (nonce === undefined || nonce === null) {
-            return true;
-        }
-    
-        /* Any nonce with .not or .skip isn't a SpoofDefinition, even if it has SpoofDefinition properties. */
-        for (let non of SpoofDefinition.skipNames) {
-            if (nonce[non] !== undefined) {
-                return true;
-            }
-        }
-        
-        /* Any other nonce with any SpoofDefinition properties is a full or partial SpoofDefinition. */
-        for (let key of SpoofDefinition.#longsByShort.keys()) {
-            let value = SpoofDefinition.#longsByShort.get(key);
-        
-            if (nonce[key] !== undefined) {
-                return false;
-            }
-            
-            if (nonce[value] !== undefined) {
-                return false;
-            }
-        }
-    
-        /* Any nonce without SpoofDefinition properties is not a spoof. */
-        return true;
-    }
-    
-    static isASpoof(nonce) {
-        return !this.isNotASpoof(nonce);
-    }
-
-    static fromNonceTuple(nonce) /* passed */ {
-        // Empty, since properties can be set 
-        // by either of two nonce naming styles.
-        let tuple = new SpoofDefinition();
-
-        let shortNames = SpoofDefinition.#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 = SpoofDefinition.#longsByShort.get(shortName);
-            tuple[shortName] = shortName in nonce ? nonce[shortName] : nonce[longName];
-        }
-
-        // Back to caller.
-        return tuple;
-    }
-
-    // region Dependencies of nonce-tuple initing methods
-
-    static maybeRestartFull(full, latest) /* passed */ {
-        // When a (new) spoof target is named, return the new 
-        // SpoofDefinition to wipe out all reused spoof values.
-        if (latest.target !== undefined) {
-            full = latest;
-        }
-
-        return full;
-    }
-
-    combineWith(other) {
-        let shortNames = SpoofDefinition.#longsByShort.keys();
-
-        for (let shortName of shortNames) {
-            SpoofDefinition.combineValues(this, other, shortName);
-        }
-    }
-
-    static combineValues(self, other, name) /* passed */ {
-        // Property may still end up undefined.
-        if (self[name] === undefined) {
-            self[name] = other[name];
-        }
-    }
-
-    // endregion Dependencies of nonce-tuple initing methods
-
-    // endregion Initing, including constructor()
-
-    // 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
-}