risei 1.3.4 → 2.0.1

package/system/TypeAnalyzer.js

@@ -1,19 +1,28 @@
 /**/
 
+import TypeIdentifier from "./TypeIdentifier.js";
+import Types from "./Types.js";
+
 /* Used to analyze classes / members of classes being tested. */
 
-export class TypeAnalyzer {
+export default class TypeAnalyzer {
     // region Definitions
 
     static constructorName = "constructor";
-    static getName = "get";
-    static setName = "set";
+    static accessorOfPrivate = "Cannot read private member";
 
     // endregion Definitions
 
+    /* Returns true if member is defined for 
+       instances.  Returns false otherwise. */
+    static isInstanceMember(type, name) {
+        /* Reusing logic instead of repeating it. */
+        return !TypeAnalyzer.isStaticMember(type, name);
+    }
+
     /* Returns true if member is static (value or accessor 
        property, or method).  Returns false otherwise. */
-    static memberIsStatic(type, name) /* passed */ {
+    static isStaticMember(type, name) /* passed */ {
         // Constructor of class type, available with `in`, 
         // is not the constructor normally being sought, 
         // which instead is treated as instance-hosted.
@@ -35,88 +44,41 @@ export class TypeAnalyzer {
 
     /* Returns true if instance or static member is a method.
        Returns false if member is any kind of property. */
-    static memberIsMethod(type, name) /* passed */ {
-        return !TypeAnalyzer.memberIsProperty(type, name);
-    }
+    static isMethodMember(type, name) /* passed */ {
+        /* A method is always defined either on a type or 
+           its prototype, even if declared on a superclass. */
 
-    /* Returns true if instance or static member is a property 
-       (value or accessor).  Returns false if member is a method. */
-    static memberIsProperty(type, name) /* passed */ {
-        // Constructor is never a property and is irregular, 
-        // so other type-analysis code can't handle it.
-        if (name === TypeAnalyzer.constructorName) {
-            return false;
-        }
+        try {
+            let anyInstanceType = TypeIdentifier.identify(type.prototype[name]);
+            let anyStaticType = TypeIdentifier.identify(type[name]);
 
-        // Static methods and properties (value or accessor) are on type.
-        if (name in type) {
-            return TypeAnalyzer.#staticMemberIsProperty(type, name);
-        }
-        
-        // Methods and accessor properties are on prototype.
-        if (name in type.prototype) {
-            return TypeAnalyzer.#instanceMemberIsProperty(type.prototype, name);
-        }
+            /* Excludes class "functions", which are not methods. */
+            let isInstanceMethod = anyInstanceType === Types.isFunction;
+            let isStaticMethod = anyStaticType === Types.isFunction;
 
-        // Instance value properties are not on type or prototype.
-        return true;
-    }
-    
-    // region Dependencies of memberIsProperty()
-    
-    /* Algorithm specialized with function check for static members. */
-    static #staticMemberIsProperty(type, name) {
-        let descriptor = Object.getOwnPropertyDescriptor(type, name);
-        
-        // If on type and has accessors, it's a static accessor property.
-        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
-            return true;
+            /* Returns net method-ness; if not found at all, a property 
+               is assumed (true as long as the member exists at all.) */
+            return isInstanceMethod || isStaticMethod;
         }
-        
-        // If on type and has non-Function .value, it's a static value property.
-        if (TypeAnalyzer.#doesNotHaveFunctionValue(descriptor)) {
-            return true;
+        catch (thrown) {
+            /* If private fields are used behind public accessor properties, 
+               there's a characteristic message which shows it's not a method.  
+               It may be a property returning a function, but not a method. */
+            if (thrown.message.startsWith(TypeAnalyzer.accessorOfPrivate)) {
+                return false;
+            }
+
+            /* Other throws are unpredictable and mean there's a problem. */
+            throw thrown;
         }
 
-        // If on type but not a static property, it's a static method.
-        return false;
+        /* Probably never reached.  No previous throw, but some unknown problem. */
+        throw new Error("Unable to determine method vs. property state.");
     }
 
-    /* Algorithm specialized for instance members, no function check. */
-    static #instanceMemberIsProperty(prototype, name) {
-        let descriptor = Object.getOwnPropertyDescriptor(prototype, name);
-        
-        // If on prototype and has accessors, it's an accessor property.
-        if (TypeAnalyzer.#doesHaveAccessorProps(descriptor)) {
-            return true;
-        }
-        
-        // If on prototype but not an accessor property, it's a method.
-        return false;
-    }
-    
-    // region Internally reused dependencies of other memberIsProperty() dependencies
-    
-    static #doesHaveAccessorProps(descriptor) /* verified */ {
-        // Accessor properties have one or both of these in descriptor.
-        if (TypeAnalyzer.getName in descriptor || TypeAnalyzer.setName in descriptor) {
-            return true;
-        }
-        
-        return false;
-    }
-    
-    static #doesNotHaveFunctionValue(descriptor) /* verified */ {
-        // Simple inverter of other method for readability.
-        return !TypeAnalyzer.#doesHaveFunctionValue(descriptor);
-    }
-    
-    static #doesHaveFunctionValue(descriptor) /* verified */ {
-        // If no member, .value of undefined.
-        return descriptor.value instanceof Function;
+    /* Returns true if instance or static member is a property 
+       (value or accessor).  Returns false if member is a method. */
+    static isPropertyMember(type, name) /* passed */ {
+        return !TypeAnalyzer.isMethodMember(type, name);
     }
-
-    // endregion Internally reused dependencies of other memberIsProperty() dependencies
-
-    // endregion Dependencies of memberIsProperty()
 }

package/system/TypeIdentifier.js

@@ -1,9 +1,10 @@
 /**/
 
-import { Types } from "./Types.js";
+import Types from "./Types.js";
+import ATestSource from "./ATestSource.js";
 
-export class TypeIdentifier {
-    identify(value) /* passed */ {
+export default class TypeIdentifier {
+    static identify(value) /* passed */ {
         // Basis for most top branching.
         let rawType = typeof value;
 
@@ -26,13 +27,17 @@ export class TypeIdentifier {
                 return Types.isDate;
             }
             
+            if (value instanceof Error) {
+                return Types.isError;
+            }
+            
             if (value === null) {
                 return Types.isNull;
             }
             
             return Types.isObject;
         }
-        
+
         // Functions and classes are both "function" to Javascript.
         if (rawType === "function") {
             // Functions can be anonymous.
@@ -53,17 +58,22 @@ export class TypeIdentifier {
             // Function but not class is a named function.
             return Types.isFunction;
         }
-    
+
         // Strings may be handled specially.
         if (typeof value === "string") {
             return Types.isString;
         }
-        
-        // Undefined is different from the rest.
+
+        // Undefined is different from most.
         if (value === undefined) {
             return Types.isUndefined;
         }
-        
+
+        // Undef Symbol is different from most.
+        if (value === ATestSource.undefSymbol) {
+            return Types.isUndefSymbol;
+        }
+
         // Non-string values all handled the same.
         return Types.isValue;
     }

package/system/Types.js

@@ -1,6 +1,6 @@
 /**/
 
-export class Types {
+export default class Types {
     /* This class is essentially an enum. */
     
     static isValue = "value";
@@ -12,6 +12,8 @@ export class Types {
     static isFunction = "function";
     static isClass = "class";
     static isDate = "date";
+    static isError = "error";
     static isUndefined = "undefined";
+    static isUndefSymbol = "undefsym";
     static isNull = "null";
 }

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