risei 1.1.2 → 1.3.0

package/system/TestStages.js

@@ -1,6 +1,6 @@
 /**/
 
-import { TestTuple } from "./TestTuple.js";
+import { TestDefinition } from "./TestDefinition.js";
 import { TotalComparer } from "./TotalComparer.js";
 import { TotalCopier } from "./TotalCopier.js";
 
@@ -14,14 +14,6 @@ export class TestStages {
     static #comparer = new TotalComparer();
     static #copier = new TotalCopier();
 
-    setLocalInitorsAndInputs(test) /* passed */ {
-        /* Sets local__ of each to a copy of the original, 
-           so any mutated args aren't collapsed forward. */
-
-        test.localInitors = TestStages.#copier.copy(test.with);
-        test.localInputs = TestStages.#copier.copy(test.in);
-    }
-    
     anyPreTargetingGroundwork(test) {
         // Spoofing of class members here.
         // Setting any static properties here.
@@ -37,7 +29,7 @@ export class TestStages {
             return;
         }
 
-        let callable = TestTuple.plainNameOf(test.of);
+        let callable = TestDefinition.plainNameOf(test.of);
         
         let target = test.isInstanceTest 
             ? this.#supplyInstanceLocalTarget(test, callable) 
@@ -61,7 +53,7 @@ export class TestStages {
     }
 
     #supplyInstanceLocalTarget(test, callable) /* verified */ {
-        let instance = new test.on.prototype.constructor(...test.localInitors);
+        let instance = new test.on.prototype.constructor(...test.with);
         
         // Methods are called on instance directly.  
         // Properties are called on instance in nonce.
@@ -79,8 +71,8 @@ export class TestStages {
            or a nonce method for a property test. */
         
         test.localCallable = test.isMethodTest 
-            ? TestTuple.plainNameOf(test.method) 
-            : TestTuple.nonceLocalCallableName;
+            ? TestDefinition.plainNameOf(test.method) 
+            : TestDefinition.nonceLocalCallableName;
     }
     
     anyPostTargetingGroundwork(test) {

package/system/TotalCopier.js

@@ -1,6 +1,11 @@
 /**/
 
+import { TypeIdentifier } from "./TypeIdentifier.js";
+import { Types } from "./Types.js";
+
 export class TotalCopier {
+    #identifier = new TypeIdentifier();
+
     copy(original) /* passed */ {
         return this.recursiveCopy(original);
     }
@@ -13,8 +18,10 @@ export class TotalCopier {
                       not a value; then recursively replaced at next level, and so on. */
 
         let copy;
+        
+        let type = this.#identifier.identify(original);
 
-        if (Array.isArray(original)) {
+        if (type === Types.isArray) {
             copy = [ ];
             
             // Traversal construction with recursion.
@@ -26,7 +33,7 @@ export class TotalCopier {
             return copy;
         }
         
-        if (original instanceof Map) {
+        if (type === Types.isMap) {
             copy = new Map();
 
             // Traversal construction with recursion.
@@ -38,7 +45,7 @@ export class TotalCopier {
             return copy;
         }
         
-        if (original instanceof Set) {
+        if (type === Types.isSet) {
             copy = new Set();
 
             // Traversal construction with recursion.
@@ -50,10 +57,27 @@ export class TotalCopier {
             return copy;
         }
 
-        if (original instanceof Date) {
+        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) {
             copy = { };