risei 1.1.0 → 1.1.2

package/system/TotalDisplayer.js

@@ -0,0 +1,143 @@
+/**/
+
+import { TypeIdentifier } from "./TypeIdentifier.js";
+import { Types } from "./Types.js";
+
+export class TotalDisplayer {
+    #identifier;
+
+    constructor() /* verified */ {
+        this.#identifier = new TypeIdentifier();
+    }
+
+    display(value) /* passed */ {
+        let typeId = this.#identifier.identify(value);
+
+        switch (typeId) {
+            case Types.isValue: return this.displayValue(value);
+            case Types.isString: return this.displayString(value);
+            case Types.isArray: return this.displayArray(value);
+            case Types.isMap: return this.displayMap(value);
+            case Types.isSet: return this.displaySet(value);
+            case Types.isClass: return this.displayClass(value);
+            case Types.isFunction: return this.displayFunction(value);
+            case Types.isObject: return this.displayObject(value);
+            case Types.isDate: return this.displayValue(value);
+            case Types.isUndefined: return this.displayUndefined(value);
+            case Types.isNull: return this.displayNull(value);
+        }
+    }
+
+    // region Displaying different types
+
+    /* Plain values (numbers, booleans) and Dates 
+       are handled together using JS defaults. */
+    displayValue(value) /* passed */ {
+        return `${ value }`;
+    }
+
+    displayString(value) /* passed */ {
+        return `"${ value }"`;
+    }
+
+    displayArray(value) /* passed */ {
+        // Cross-recursion.
+        let outputs = value
+            .map(x => this.display(x));
+
+        // Brackets around, commas between.
+        let output = `[${ outputs.join(",") }]`;
+
+        // And back to caller.
+        return output;
+    }
+
+    displayMap(value) /* passed */ {
+        // Array used for clearer display.
+        let items = [ ];
+
+        // Each key-value pair is handled individually.
+        for (let key of value.keys()) {
+            let item = value.get(key);
+
+            // Cross-recursion.
+            items.push(`${ this.display(key) }:${ this.display(item) }`);
+        }
+
+        // Key-value pairs are all listed together.
+        let output = `Map{${ items.join(",") }}`;
+        return output;
+    }
+
+    displaySet(value) /* passed */ {
+        // Array used for clearer display.
+        let items = [ ];
+
+        // Each element is handled individually.
+        for (let item of value) {
+            // Cross-recursion for styling values.
+            let display = `${ this.display(item) }`;
+            items.push(display);
+        }
+
+        // Items are all listed together.
+        let output = `Set{${ items.join(",") }}`;
+        return output;
+    }
+
+    displayClass(value) /* passed */ {
+        // Class definitions have a .name.
+        let output = value.name;
+        return output;
+    }
+
+    displayFunction(value) /* passed */ {
+        // toString() lists the definition, including code.
+        let output = value.toString();
+
+        // Most whitespace is eliminated for readability.
+        output = output.replace(/(\r\n?)/g, "");
+        output = output.replace(/\s{2,}/g, " ");
+
+        // Back to caller.
+        return output;
+    }
+
+    displayObject(value) /* passed */ {
+        // Use toString() text if it's meaningful.
+        let asString = value.toString();
+
+        if (asString !== "[object Object]") {
+            return asString;
+        }
+
+        // If toString() not meaningful, list members.
+        let items = [ ];
+
+        // Each property of the object is handled individually.
+        for (let p in value) {
+            // Cross-recursion.
+            let item = this.display(value[p]);
+            items.push(`${ p }:${ item }`);
+        }
+
+        // Properties are all listed together.
+        let output = `{ ${ items.join(", ") } }`;
+        
+        // If empty, internal empty space reduced.
+        output = output !== "{  }" ? output : "{ }";
+        
+        // Back to caller.
+        return output;
+    }
+
+    displayUndefined(value) /* passed */ {
+        return "undefined";
+    }
+
+    displayNull(value) /* passed */ {
+        return "null";
+    }
+
+    // endregion Displaying different types
+}

package/system/TypeAnalyzer.js

@@ -0,0 +1,103 @@
+/**/
+
+/* Used to analyze classes / members of classes being tested. */
+
+export class TypeAnalyzer {
+    // region Definitions
+
+    static constructorName = "constructor";
+    static getName = "get";
+    static setName = "set";
+
+    // endregion Definitions
+
+    // region Fields
+
+    #type;
+
+    // endregion Fields
+
+    constructor(type) {
+        this.#type = type;
+    }
+
+    /* Returns true if instance or static member is a property (value or accessor).  Returns false if member is a method. */
+    memberIsProperty(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;
+        }
+    
+        // Static methods and properties (value or accessor) are on type.
+        if (name in this.#type) {
+            return this.#staticMemberIsProperty(this.#type, name);
+        }
+        
+        // Methods and accessor properties are on prototype.
+        if (name in this.#type.prototype) {
+            return this.#instanceMemberIsProperty(this.#type.prototype, name);
+        }
+
+        // Instance value properties are not on type or prototype.
+        return true;
+    }
+    
+    // region Dependencies of memberIsProperty()
+    
+    /* Algorithm specialized with function check for static members. */
+    #staticMemberIsProperty(type, name) {
+        let descriptor = Object.getOwnPropertyDescriptor(type, name);
+        
+        // If on type and has accessors, it's a static accessor property.
+        if (this.#doesHaveAccessorProps(descriptor)) {
+            return true;
+        }
+        
+        // If on type and has non-Function .value, it's a static value property.
+        if (this.#doesNotHaveFunctionValue(descriptor)) {
+            return true;
+        }
+
+        // If on type but not a static property, it's a static method.
+        return false;
+    }
+
+    /* Algorithm specialized for instance members, no function check. */
+    #instanceMemberIsProperty(prototype, name) {
+        let descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+        
+        // If on prototype and has accessors, it's an accessor property.
+        if (this.#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
+    
+    #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;
+    }
+    
+    #doesNotHaveFunctionValue(descriptor) /* verified */ {
+        // Simple inverter of other method for readability.
+        return !this.#doesHaveFunctionValue(descriptor);
+    }
+    
+    #doesHaveFunctionValue(descriptor) /* verified */ {
+        // If no member, .value of undefined.
+        return descriptor.value instanceof Function;
+    }
+
+    // endregion Internally reused dependencies of other memberIsProperty() dependencies
+
+    // endregion Dependencies of memberIsProperty()
+}

package/system/TypeIdentifier.js

@@ -0,0 +1,70 @@
+/**/
+
+import { Types } from "./Types.js";
+
+export class TypeIdentifier {
+    identify(value) /* passed */ {
+        // Basis for most top branching.
+        let rawType = typeof value;
+
+        // Array, Map, Set, Date, null, and actual 
+        // objects are all "object" to JavaScript.
+        if (rawType === "object") {
+            if (Array.isArray(value)) {
+                return Types.isArray;
+            }
+        
+            if (value instanceof Map) {
+                return Types.isMap;
+            }
+            
+            if (value instanceof Set) {
+                return Types.isSet;
+            }
+            
+            if (value instanceof Date) {
+                return Types.isDate;
+            }
+            
+            if (value === null) {
+                return Types.isNull;
+            }
+            
+            return Types.isObject;
+        }
+        
+        // Functions and classes are both "function" to Javascript.
+        if (rawType === "function") {
+            // Functions can be anonymous.
+            if (!value.name) {
+                return Types.isFunction;
+            }
+        
+            // Classes all start with this syntax 
+            // in their defs (never with `export`).
+            let classSyntax = `class ${ value.name }`;
+            
+            let definition = value.toString();
+            
+            if (definition.startsWith(classSyntax)) {
+                return Types.isClass;
+            }
+            
+            // 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.
+        if (value === undefined) {
+            return Types.isUndefined;
+        }
+        
+        // Non-string values all handled the same.
+        return Types.isValue;
+    }
+}

package/system/Types.js

@@ -0,0 +1,17 @@
+/**/
+
+export class Types {
+    /* This class is essentially an enum. */
+    
+    static isValue = "value";
+    static isString = "string";
+    static isArray = "array";
+    static isObject = "object";
+    static isMap = "map";
+    static isSet = "set";
+    static isFunction = "function";
+    static isClass = "class";
+    static isDate = "date";
+    static isUndefined = "undefined";
+    static isNull = "null";
+}

package/public/javascript/SpoofObjectMethodsFixture.js

@@ -1,52 +0,0 @@
-/* */
-
-import { ASpoofingFixture } from "./ASpoofingFixture.js";
-import { SpoofTuple } from "./SpoofTuple.js";
-
-export class SpoofObjectMethodsFixture extends ASpoofingFixture {
-    constructor() {
-        super("SpoofObjectMethodsFixture", "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 element, or leaving it in place if not a spoof.
-        for (let topic of topics) {
-            for (let at = 0; at < topic.length; at++) {
-                let target = topic[at];
-                topic[at] = this.spoofTarget(target);
-            }
-        }
-    }
-
-    spoofTarget(target) {
-        // Non-spoofs are returned unchanged.
-        if (SpoofTuple.isNotASpoof(target)) {
-            return target;
-        }
-
-        // Spoofs are converted to their type.
-        let tuple = SpoofTuple.fromNonceTuple(target);
-        
-        // Actually spoofing.
-        let spoof = this.#supplySpoof(tuple);
-        return spoof;
-    }
-
-    #supplySpoof(target) {
-        // Common case.
-        let ofAsPairs = [{ of: target.method, as: target.output }];
-
-        // Complex case.
-        if (!target.method) {
-            ofAsPairs = target.output;
-        }
-
-        let spoof = super.spoofObjectTree(ofAsPairs);
-        return spoof;
-    }
-}