risei 1.3.4 → 2.0.1

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
-}

package/system/TestFrameChooser.js

@@ -1,54 +0,0 @@
-/**/
-
-export class TestFrameChooser {
-    // Used for special test cases.
-    constructorName = "constructor";
-    staticName = "static";
-    throwName = "throw";
-    
-    frames;
-    
-    constructor(frameSource) /* verified */ {
-        this.frames = frameSource;
-    }
-
-    supplyTestFrame(test) /* passed */ {
-        // If `.and` includes "static", a call of a static member 
-        // is made, and the actual is its return value.
-        if (test.isStaticTest) {
-            if (test.isThrowTest) {
-                return this.frames.testThrowResultAfterStaticCall;
-            }
-        
-            // If .from, a static call is made, then the actual is 
-            // retrieved from a named code element or custom code.
-            if (test.isRetrievalTest) {
-                return this.frames.testCodeElementAfterStaticCall;
-            }
-
-            // Otherwise, the return value 
-            // of the static call is used.
-            return this.frames.testReturnValueOfStaticCall;
-        }
-
-        // Constructors are a special case; no second call should 
-        // be made, and actual must be retrieved from property.
-        if (test.isConstructorTest) {
-            return this.frames.testCodeElementAfterConstruction;
-        }
-        
-        if (test.isThrowTest) {
-            return this.frames.testThrowResultAfterCall;
-        }
-
-        // If .from, a call of the target is made, then the actual 
-        // is retrieved from a named code element or custom code.
-        if (test.isRetrievalTest) {
-            return this.frames.testCodeElementAfterCall;
-        }
-
-        // The most common case: the target is called, 
-        // and the actual is its return value.
-        return this.frames.testReturnValueOfCall;
-    }
-}

package/system/TestFrames.js

@@ -1,232 +0,0 @@
-/**/
-
-import { AComparer } from "./AComparer.js";
-import { TotalComparer } from "./TotalComparer.js";
-
-export class TestFrames {
-    /* &cruft, refactor to merge with same on TestFrameChooser */
-    // Used for special test cases.
-    constructorName = "constructor";
-    staticName = "static";
-
-    /* &cruft, probably refactor comparing usage */
-    /* Each test frame is bound to the calling instance of TestRunner, 
-       for now at least.  TestRunner includes #compare() for now. */
-
-    #comparer;
-
-    constructor() {
-        // Comparer is inited once for all tests, since compare() is reentrant.
-        this.#comparer = new TotalComparer();
-    }
-    
-    // The most basic test: whether a call of 
-    // a method returns the expected value.
-    testReturnValueOfCall(test) {
-        /* Groundwork. */
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.with);  // Must use `...`.
-        
-        this.#anyPropertySetting(target, test.settables);
-
-        /* Exercising the code. */
-        test.actual = target[test.of](...test.in);  // Must use `...`.
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    testReturnValueOfStaticCall(test) {
-        /* Groundwork. */
-        /* No instance is constructed. */
-        
-        let unsettables = this.#anyOriginalPropertyGetting(test.type, test.settables);
-        this.#anyPropertySetting(test.type, test.settables);
-        
-        /* Exercising the code. */
-        test.actual = test.on[test.of](...test.in);  // Must use `...`.
-        
-        this.#anyPropertyUnsetting(test.type, unsettables);
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // The second-most basic test: whether a property 
-    // has the expected value after a method call.
-    testCodeElementAfterCall(test) {
-        /* Groundwork. */
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.with);  // Must use `...`.
-
-        /* Exercising the code. */
-        target[test.of](...test.in);  // Must use `...`.
-
-        /* Retrieving. */
-        // The `actual` is a property or other code element somewhere.
-        test.actual = this.#supplyNonReturnActual(test, target);
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-    
-    testCodeElementAfterStaticCall(test) {
-        /* Groundwork. */
-        /* No instance is constructed. */
-        
-        /* Exercising the code. */
-        test.on[test.of](...test.in);  // Must use `...`.
-        
-        /* Retrieving. */
-        test.actual = this.#supplyNonReturnActual(test);  // No `target` here.
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // The third-most basic test: whether a property has 
-    // the expected value after an object is constructed.
-    testCodeElementAfterConstruction(test) {
-        /* Groundwork. */
-        // For definition consistency, initing with test.in, not test.with.
-        let prototype = test.on.prototype;
-        
-        /* Exercising the code. */
-        let target = new prototype.constructor(...test.in);  // Must use `...`.
-
-        /* Retrieving. */
-        // The `actual` is a property or other code element somewhere.
-        test.actual = this.#supplyNonReturnActual(test, target);
-
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-    
-    testThrowResultAfterCall(test) {
-        /* Groundwork. */
-        let prototype = test.on.prototype;
-        let target = new prototype.constructor(...test.with);  // Must use `...`.
-        
-        /* Exercising the code. */
-        try {
-            target[test.of](...test.in);  // Must use `...`.
-        }
-        /* Retrieving. */
-        catch (thrown) {
-            test.actual = thrown.message;
-        }
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-    
-    testThrowResultAfterStaticCall(test) {
-        /* Groundwork. */
-        /* No instance is constructed. */
-        
-        /* Exercising the code. */
-        try {
-            test.on[test.of](...test.in)  // Must use `...`.
-        }
-        catch (thrown) {
-            test.actual = thrown.message;
-        }
-        
-        /* Comparing. */
-        test.didPass = this.#compare(test.out, test.actual);
-    }
-
-    // region Dependencies of test frames
-
-    #anyOriginalPropertyGetting(target, settables) {
-        if (!Array.isArray(settables)) {
-            return;
-        }
-    
-        let unsettables = [ ];
-        
-        for (let settable of settables) {
-            // Not a setter tuple.
-            if (!settable.of) {
-                continue;
-            }
-            
-            // Retaining original.
-            let original = target[settable.of];
-            let unsettable = { of: settable.of, as: original };
-            unsettables.push(unsettable);
-        }
-        
-        return unsettables;
-    }
-
-    #anyPropertySetting(target, settables) {
-        // No properties to set.
-        if (!Array.isArray(settables)) {
-            return;
-        }
-    
-        for (let settable of settables) {
-            // Not a setter tuple.
-            if (!settable.of) {
-                continue;
-            }
-
-            // Actually setting property.
-            target[settable.of] = settable.as;
-        }
-    }
-    
-    #anyPropertyUnsetting(target, unsettables) {
-        // Unsetting is the same as setting, 
-        // but with tuples of original values.
-        return this.#anyPropertySetting(target, unsettables);
-    }
-
-    #compare(expected, actual) {
-        return this.#comparer.compare(expected, actual);
-    }
-
-    #supplyNonReturnActual(test, target) {
-        // When there is a .from that's a string, 
-        // the actual is the named target member.
-        if (typeof test.from === "string") {
-            // Common member host; 
-            // undefined if static.
-            let host = target;
-            
-            // When .and defines static.
-            if (this.#doesAddressStatics(test)) {
-                host = test.on;
-            }
-        
-            return host[test.from];
-        }
-        
-        // When there is a .from that's a function, 
-        // the actual is the result of calling it, 
-        // given everything that might be needed.
-        if (test.from instanceof Function) {
-            return test.from(target, test);
-        }
-
-        // When there is any other .from, the actual is the
-        // value of the code element provided as .from.
-        return test.from;
-    }
-    
-    /* &cruft, refactor to merge with same on TestFrameChooser */
-    #doesAddressStatics(test) {
-        if (typeof test.and === "string") {
-            if (test.and.includes(this.staticName)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    // endregion Dependencies of test frames
-
-
-}

package/system/TotalCopier.js

@@ -1,106 +0,0 @@
-/**/
-
-import { TypeIdentifier } from "./TypeIdentifier.js";
-import { Types } from "./Types.js";
-
-export class TotalCopier {
-    #identifier = new TypeIdentifier();
-
-    copy(original) /* passed */ {
-        return this.recursiveCopy(original);
-    }
-
-    recursiveCopy(original) /* verified */ {
-        /* &cruft, factor, possibly abstracting similar code, 
-                   and/or return copy only once, or similar */
-
-        /* Algorithm: First copied at current level by value if a value, by reference if 
-                      not a value; then recursively replaced at next level, and so on. */
-
-        let copy;
-        
-        let type = this.#identifier.identify(original);
-
-        if (type === Types.isArray) {
-            copy = [ ];
-            
-            // Traversal construction with recursion.
-            for (let item of original) {
-                let next = this.recursiveCopy(item);
-                copy.push(next);
-            }
-            
-            return copy;
-        }
-        
-        if (type === Types.isMap) {
-            copy = new Map();
-
-            // Traversal construction with recursion.
-            for (let entry of original.entries()) {
-                let next = this.recursiveCopy(entry);
-                copy.set(next[0], next[1]);
-            }
-            
-            return copy;
-        }
-        
-        if (type === Types.isSet) {
-            copy = new Set();
-
-            // Traversal construction with recursion.
-            for (let value of original.values()) {
-                let next = this.recursiveCopy(value);
-                copy.add(next);
-            }
-
-            return copy;
-        }
-
-        if (type === Types.isDate) {
-            copy = new Date(original);
-            return copy;
-        }
-        
-        // Actually copying isn't needed (or desirable) here, 
-        // since should always point to same thing regardless.
-        if (type === Types.isClass) {
-            copy = original;
-            return copy;
-        }
-
-        // The workaround here makes a true independent copy of the 
-        // original function, regardless of its definition style.
-        if (type === Types.isFunction) {
-            let passer = [ original ];
-            passer = [ ...passer ];
-            copy = passer[0];
-
-            return copy;
-        }
-
-        if (original instanceof Object) {
-            // If original has a prototype, it's probably a class instance, 
-            // so it's constructed, so it includes all methods and accessors.
-            let prototype = Object.getPrototypeOf(original);
-            copy = prototype !== null ? new prototype.constructor() : { };
-            
-            let keys = Object.keys(original);
-            
-            // Settable properties are added, with recursion.
-            for (let key of Object.keys(original)) {
-                let next = this.recursiveCopy(original[key]);
-                copy[key] = next;
-            }
-            
-            return copy;
-        }
-        
-        /* &cruft, other object types here */
-
-        // All object types exhausted, so this is a value, 
-        // which can be used directly for a copy.
-        copy = original;
-        return copy;
-    }
-}