risei 1.0.4 → 1.1.1

package/{public/javascript → system}/TestTuple.js

@@ -1,8 +1,23 @@
 /**/
 
+import { TypeAnalyzer } from "./TypeAnalyzer.js";
+
 /* Defines what is found in a test-definition tuple (TDT).  Actual TDTs don't need to be instances of this class. */
 
 export class TestTuple {
+    // region Definitions
+
+    static staticName = "static";
+    static throwName = "throw";
+    static constructorName = "constructor";
+    static nonceLocalCallableName = "localCallable";
+    static dotOperator = ".";
+    static colonOperator = ":";
+    static parensOperator = "()";
+    static operatorsRegExp = /\.|:|\(\)/g;
+
+    // endregion Definitions
+
     // region Static fields
 
     static longsByShort = new Map([
@@ -11,6 +26,7 @@ export class TestTuple {
         [ "with", "initors" ],
         [ "of", "method" ],
         [ "plus", "spoofed" ],
+        [ "amid", "settables" ],
         [ "in", "inputs" ],
         [ "out", "output" ],
         [ "from", "source" ],
@@ -21,6 +37,12 @@ export class TestTuple {
 
     // region Private fields
 
+    #typeAnalyzer;
+
+    // endregion Private fields
+
+    // region Fields
+
     /* These longer names match the constructor-arg names. 
        The short-name properties use the same fields. */
 
@@ -29,12 +51,25 @@ export class TestTuple {
     initors;
     method;
     spoofed;
+    settables;
     inputs;
     output;
     source;
     factors;
+
+    /* &cruft, possibly drop defaults when properties settable in tests */
+    // These fields are not part of collapse-forward system:
+    // Local copies of args; local test targets; outcome fields.
+    localInitors = [ ];
+    localInputs = [ ];
     
-    // endregion Private fields
+    localTarget;
+    localMethod;
+    
+    actual;
+    thrown;
+    
+    // endregion Fields
 
     // region Properties
 
@@ -81,6 +116,15 @@ export class TestTuple {
     set plus(value) {
         this.spoofed = value;
     }
+    
+    /* &cruft, rename this .amid property pair */
+    get amid() { 
+        return this.settables; 
+    }
+    
+    set amid(value) { 
+        this.settables = value; 
+    }
 
     get in() {
         return this.inputs;
@@ -116,7 +160,7 @@ export class TestTuple {
 
     // endregion Test definition, short names
 
-    // region Tuple state
+    // region Tuple state and dependencies
 
     get isRunnable() {
         let isRunnable
@@ -130,7 +174,71 @@ export class TestTuple {
         return isRunnable;
     }
 
-    // endregion Tuple state
+    get isInstanceTest() /* passed */ {
+        return !this.isStaticTest || this.isConstructorTest;
+    }
+
+    get isStaticTest() /* passed */ {
+        let does = this.andStringContains(TestTuple.staticName);
+        return does;
+    }
+    
+    get isThrowTest() /* passed */ {
+        let is = this.andStringContains(TestTuple.throwName);
+        return is;
+    }
+
+    /* Needed externally, and dependency 
+       of all .and-based properties. */
+    andStringContains(keyword) /* passed */ {
+        let doesContain 
+            = typeof this.and === "string"
+            && this.and.includes(keyword);
+
+        return doesContain;
+    }
+
+    get isConstructorTest() /* passed */ {
+        let plainTarget = TestTuple.plainNameOf(this.of);
+        return plainTarget === TestTuple.constructorName;
+    }
+
+    get isMethodTest() /* passed */ {
+        return !this.isPropertyTest;
+    }
+
+    get isPropertyTest() /* passed */ {
+        let plainName = TestTuple.plainNameOf(this.of);
+        
+        let isPropertyTest 
+            = this.of.startsWith(TestTuple.dotOperator) 
+            || this.of.endsWith(TestTuple.colonOperator) 
+            || this.#typeAnalyzer.memberIsProperty(plainName);
+        
+        return isPropertyTest;
+    }
+
+    get isRetrievalTest() /* passed */ {
+        // Falsy code elements never are a retrieval.
+        if (!this.from) {
+            return false;
+        }
+        
+        // If a (non-falsy) string, must be a retrieval.
+        if (typeof this.from === "string") {
+            return true;
+        }
+        
+        // If a function, is a retrieval.
+        if (this.from instanceof Function) {
+            return true;
+        }
+        
+        // Anything else is not a retrieval.
+        return false;
+    }
+
+    // endregion Tuple state and dependencies
 
     // endregion Properties
 
@@ -138,16 +246,19 @@ export class TestTuple {
 
     /* Constructor can't use param names like `for`, because when not .-prefixed, they are keywords. */
 
-    constructor(nature, type, spoofed, initors, method, inputs, output, source, factors) {
-        this.nature = nature;
-        this.type = type;
-        this.spoofed = spoofed;
-        this.initors = initors;
-        this.method = method;
-        this.inputs = inputs;
-        this.output = output;
-        this.source = source;
-        this.factors = factors;
+    constructor(nature, type, spoofed, initors, settables, method, inputs, output, source, factors) {
+        this.nature = nature;        // .for 
+        this.type = type;            // .on 
+        this.spoofed = spoofed;      // .plus 
+        this.initors = initors;      // .with 
+        this.settables = settables;  // .amid 
+        this.method = method;        // .of 
+        this.inputs = inputs;        // .in 
+        this.output = output;        // .out 
+        this.source = source;        // .from 
+        this.factors = factors;      // .and 
+
+        this.#typeAnalyzer = new TypeAnalyzer(this.type);
     }
 
     static fromNonceTuples(nonces) {
@@ -241,4 +352,12 @@ export class TestTuple {
 
     // endregion Initing, including constructor()
 
+    // region Other statics
+
+    static plainNameOf(name) /* passed */ {
+        let plain = name.replaceAll(TestTuple.operatorsRegExp, "");
+        return plain;
+    }
+
+    // endregion Other statics
 }

package/{public/javascript → system}/TotalComparer.js

@@ -36,6 +36,10 @@ export class TotalComparer extends AComparer {
             return this.#compareFunctions(expected, actual);
         }
         
+        if (expected instanceof Date) {
+            return this.#compareDates(expected, actual);
+        }
+        
         if (expected instanceof Object) {
             /* Traverse / recurse to leaves. */
             return this.#recurseOverObjects(expected, actual);
@@ -223,6 +227,14 @@ export class TotalComparer extends AComparer {
         return expectedCode === actualCode;
     }
 
+    #compareDates(expected, actual) /* verified */ {
+        if (!(actual instanceof Date)) {
+            return false;
+        }
+        
+        return expected.valueOf() === actual.valueOf();
+    }
+
     // endregion Dependencies of compare()
 
 }

package/system/TotalCopier.js

@@ -0,0 +1,79 @@
+/**/
+
+export class TotalCopier {
+    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;
+
+        if (Array.isArray(original)) {
+            copy = [ ];
+            
+            // Traversal construction with recursion.
+            for (let item of original) {
+                let next = this.recursiveCopy(item);
+                copy.push(next);
+            }
+            
+            return copy;
+        }
+        
+        if (original instanceof Map) {
+            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 (original instanceof Set) {
+            copy = new Set();
+
+            // Traversal construction with recursion.
+            for (let value of original.values()) {
+                let next = this.recursiveCopy(value);
+                copy.add(next);
+            }
+
+            return copy;
+        }
+
+        if (original instanceof Date) {
+            copy = new Date(original);
+            return copy;
+        }
+
+        if (original instanceof Object) {
+            copy = { };
+            
+            let keys = Object.keys(original);
+            
+            // Traversal construction 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;
+    }
+}

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";
+}