Created MultiplePrototypeChain module. Updated tests.

Author: Dr. Safi

module/concept/concept.test.js

@@ -2,7 +2,7 @@ import assert from 'assert'
 import { ClassProducer } from './dynamicClassExtention.js'
 // const ModuleContext = require('appscript/module/ModuleContext')
 
-describe('Testing different implementation concepts', () => {
+describe.skip('Testing different implementation concepts', () => {
 
     describe('Creating static classes from function', () => {
         let staticClass1 = ClassProducer({ Superclass: null /* semilar to extending Function.prototype (if it was possible as it is an object) */ })

module/multiplePrototypeChain/entrypoint.js

@@ -0,0 +1,101 @@
+let self = class MultiplePrototypeChain {
+
+
+    static newChainOnInstanceCreation({ 
+        Class, // wrap constructor of Class and create a new chain for each new instance.
+        contextInstance // The instnace to be added to the chain.
+    }) {
+        return new Proxy(Class, {
+            construct: (target, argumentsList, newConstructorFunc) => {
+                let instance = Reflect.construct(target, argumentsList)
+                instance = self.createUniqueProtoChain({ object: instance })
+                instance = self.insertObjectToPrototypeChain({ 
+                    prototypeChain: instance,
+                    objectToAdd: contextInstance,
+                    beforePrototype: contextInstance.__proto__
+                })
+                return instance
+            }             
+        })
+    }
+        
+    static createUniqueProtoChain({ object = null }) {
+        if( object == null || 
+            object.constructor == Object ||
+            object.constructor == Function)
+            return object
+        
+        let delegatedPrototype = Object.getPrototypeOf(object)
+        let nextPointerPrototype = self.createUniqueProtoChain({ object: delegatedPrototype })
+        let pointerPrototype = Object.create(nextPointerPrototype)
+        if(!pointerPrototype.hasOwnProperty('delegatedPrototype')) {
+            Object.defineProperty(pointerPrototype, 'delegatedPrototype', { value: object, writable: true, enumerable: true, configurable: true })
+        }
+        let proxyHandler = self.handlerMultiplePrototypeChainPattern({ delegatedPrototype: object })
+        pointerPrototype = new Proxy(pointerPrototype, proxyHandler)            
+        return pointerPrototype
+    }
+
+    static handlerMultiplePrototypeChainPattern({ delegatedPrototype }) {
+        return {
+            get: function(target, property, receiver) {
+                switch (property) {
+                    case 'delegatedPrototype':
+                        return Reflect.get(target, property)
+                    break;
+                    case '__proto__':
+                        return Object.getPrototypeOf(receiver)
+                    break;
+                    default:
+                    break;
+                }
+                if(delegatedPrototype.hasOwnProperty(property)) {
+                    return Reflect.get(delegatedPrototype, property)
+                } else if(Object.getPrototypeOf(target)) {
+                    return Reflect.get(Object.getPrototypeOf(target), property)
+                } else {
+                    return undefined
+                }
+            },
+            set: function(target, property, value, receiver) {
+                switch (property) {
+                    case '__proto__':
+                        return Object.setPrototypeOf(target, value)
+                    break;
+                    default:
+                        return Reflect.set(delegatedPrototype, property, value)
+                    break;
+                }
+            }
+        }
+    }
+
+    // Add an instance prototype to a prototype chain just before the instance's constructor prototype.
+    static insertObjectToPrototypeChain({
+        prototypeChain, // chain to add to
+        objectToAdd, // object to add as prototype
+        beforePrototype // location of insertion
+    }) {
+        // find position of beforePrototype with references to next and previous prototype
+        let previousPrototype = prototypeChain // starting point
+        let nextPrototype = prototypeChain.__proto__
+        while (nextPrototype && beforePrototype !== nextPrototype.delegatedPrototype) {
+            previousPrototype = nextPrototype
+            nextPrototype = nextPrototype.__proto__
+        }
+        if(!nextPrototype) return false // if no appropriate insertion position was found.
+        // create pointerPrototype to add between the previous and next prototypes.
+        let pointerPrototype = Object.create(nextPrototype)
+        if(!pointerPrototype.hasOwnProperty('delegatedPrototype')) {
+            Object.defineProperty(pointerPrototype, 'delegatedPrototype', { value: objectToAdd, writable: true, enumerable: true, configurable: true })
+        }
+        pointerPrototype = new Proxy(pointerPrototype, self.handlerMultiplePrototypeChainPattern({ 
+            delegatedPrototype: objectToAdd
+        }))
+        Object.setPrototypeOf(previousPrototype, pointerPrototype)            
+        return prototypeChain
+    }
+
+}
+
+export { self as MultiplePrototypeChain }

module/multiplePrototypeChain/entrypoint.test.js

@@ -0,0 +1,82 @@
+import assert from 'assert'
+import {MultiplePrototypeChain} from './entrypoint.js'
+
+describe('Multiple Prototype Chain creation', () => {
+    beforeEach(() => {
+    })
+    describe('Create new chain with proxied prototypes', () => {
+        class Superclass {}
+        Superclass.prototype.meta = { Class: 'Superclass'}
+        class Class extends Superclass {}
+        Class.prototype.meta = { Class: 'Class'}
+        class Subclass extends Class {}
+        Subclass.prototype.meta = { Class: 'Subclass'}
+        
+        let oldInstance = new Subclass()
+        oldInstance.x = 'x'
+        let newInstance = MultiplePrototypeChain.createUniqueProtoChain({ object: oldInstance })
+
+        it('Get properties - Preserve properties of original instance and original prototypes', () => {
+            assert.strictEqual(newInstance.x, oldInstance.x)            
+            assert.strictEqual(newInstance.meta.Class, 'Subclass')   
+            assert.strictEqual(newInstance.__proto__.meta.Class, 'Subclass')            
+            assert.strictEqual(newInstance.__proto__.__proto__.meta.Class, 'Class')            
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.meta.Class, 'Superclass')            
+        })
+
+        it('Set properties - Should be able to set properties through the proxy', () => {
+            newInstance.t = 't'
+            assert.strictEqual(newInstance.t, 't')                        
+            assert.strictEqual(newInstance.delegatedPrototype.t, 't')                        
+        })        
+    
+        it('create new prototypes with corresponding delegatedPrototypes values equal to original proto chain', () => {
+            // Subclass
+            assert.strictEqual(newInstance.__proto__.delegatedPrototype, oldInstance.__proto__)
+            // Class
+            assert.strictEqual(newInstance.__proto__.__proto__.delegatedPrototype, oldInstance.__proto__.__proto__)
+            // Superclass
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.delegatedPrototype, oldInstance.__proto__.__proto__.__proto__)
+            // Object or Function or their prototypes ...
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.__proto__, oldInstance.__proto__.__proto__.__proto__.__proto__)
+            // null 
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.__proto__.__proto__, oldInstance.__proto__.__proto__.__proto__.__proto__.__proto__)
+        })
+
+    })
+    describe('Insert object to prototypechain', () => {
+        class Superclass {}
+        Superclass.prototype.meta = { Class: 'Superclass'}
+        class Class extends Superclass {}
+        Class.prototype.meta = { Class: 'Class'}
+        class Subclass extends Class {}
+        Subclass.prototype.meta = { Class: 'Subclass'}
+        
+        let oldInstance = new Subclass()
+        // prepare for multiplechain pattern format.
+
+        oldInstance.__proto__ = { delegatedPrototype: Subclass.prototype }
+        oldInstance.__proto__.__proto__ = { delegatedPrototype: Class.prototype }
+        oldInstance.__proto__.__proto__.__proto__ = { delegatedPrototype: Superclass.prototype }
+        oldInstance.__proto__.__proto__.__proto__.__proto__ = Superclass.prototype.__proto__
+        
+        let objectToAdd = { x: 'x' }
+        let newInstance = MultiplePrototypeChain.insertObjectToPrototypeChain({
+            prototypeChain: oldInstance,
+            objectToAdd: objectToAdd,
+            beforePrototype: Superclass.prototype
+        })
+        
+        it('Object should be added as delegatedPrototype inside a pointerPrototype in specified place preserving previous chain prototypes', () => {
+            assert.strictEqual(newInstance.__proto__.delegatedPrototype, Subclass.prototype)
+            assert.strictEqual(newInstance.__proto__.__proto__.delegatedPrototype, Class.prototype)
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.delegatedPrototype, objectToAdd)
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.__proto__.delegatedPrototype, Superclass.prototype)
+            assert.strictEqual(newInstance.__proto__.__proto__.__proto__.__proto__.__proto__, Superclass.prototype.__proto__)
+        })
+    })
+        
+    
+})
+
+

module/multiplePrototypeChain/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "multiplePrototypeChain",
+    "version": "0.1.0",
+    "main": "entrypoint.js"
+}

module/populateInstancePropertyFromJson.method/entrypoint.js

@@ -5,9 +5,9 @@
  **/
 function usingGenericInstance(instance, jsonData) {
     if(jsonData) {
-        Object.entries(jsonData).forEach(
-            ([key, value]) => instance[key] = value
-        )
+        Object.entries(jsonData).forEach(([key, value]) => {
+            instance[key] = value
+        })
     }
     instance.jsonData = jsonData // to keep track of populated instances.
 }

module/reusableNestedUnit/Controller.class.js

@@ -5,6 +5,7 @@ import createInstance from 'appscript/module/createInstance.staticMethod'
 import { usingGenericInstance as populateInstancePropertyFromJson, usingThis as populateInstancePropertyFromJson_this } from 'appscript/module/populateInstancePropertyFromJson.method'
 import addStaticSubclassToClassArray from 'appscript/module/addStaticSubclassToClassArray.staticMethod'
 import prototypeChainDebug from 'appscript/module/prototypeChainDebug'
+import { MultiplePrototypeChain } from 'appscript/module/multiplePrototypeChain'
 import assert from 'assert'
 
 let debugExecuted = false
@@ -48,68 +49,19 @@ module.exports = ({
             let self = this // specific Controller that is a subclass of 'self' (ReusableController)
             let contextInstance = new self(false, ...args)
 
-            // create proxied refrence of subclasses
+            // create a new list object for proxied refrence of subclasses
             contextInstance.instanceExtendedSubclass = Object.keys(self.extendedSubclass.static)
                 .reduce((object, key) => {
-                    // add proxy to the subclass
-                    object[key] = self.createPrototypeChainOnConstructor(self.extendedSubclass.static[key]);
+                    // add proxied subclass to the list
+                    object[key] = MultiplePrototypeChain.newChainOnInstanceCreation({
+                        Class: self.extendedSubclass.static[key],
+                        contextInstance
+                    })
                     return object
                 }, {})
             return contextInstance
         }
 
-        static createPrototypeChainOnConstructor(Class) {
-            return new Proxy(Class, {
-                construct: (target, argumentsList, newConstructorFunc) => {
-                    let instance = Reflect.construct(target, argumentsList)
-                    Object.setPrototypeOf(instance, self.createUniqueProtoChain(Object.getPrototypeOf(instance)))
-                    console.log(instance.__proto__.__proto__)
-                    return instance
-                },
-                // getPrototypeOf(target) {
-
-                // }                    
-            })
-        }
-
-        static createUniqueProtoChain(currentPrototype) {
-            if( currentPrototype == null || 
-                currentPrototype.constructor == Object ||
-                currentPrototype.constructor == Function
-            ) return currentPrototype
-            
-            let delegatedPrototype = Object.getPrototypeOf(currentPrototype)
-            let pointerPrototype = Object.create(self.createUniqueProtoChain(delegatedPrototype))
-            pointerPrototype = new Proxy(pointerPrototype, {
-                get: function(target, property, receiver) {
-                    Object.defineProperty(pointerPrototype, 'delegatedPrototype', {
-                        value: currentPrototype,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true
-                    })
-                    switch (property) {
-                        case 'delegatedPrototype':
-                            return currentPrototype
-                        break;
-                        case '__proto__':
-                            return Object.getPrototypeOf(pointerPrototype)
-                        break;
-                        default:
-                        break;
-                    }
-                    if(currentPrototype.hasOwnProperty(property)) {
-                        return Reflect.get(currentPrototype, property)
-                    } else if(Object.getPrototypeOf(target)) {
-                        return Reflect.get(Object.getPrototypeOf(target), property)
-                    } else {
-                        return undefined
-                    }
-                }
-            })            
-            return pointerPrototype
-        }
-
         static initializeStaticClass() {
             if(methodInstanceName && superclass && superclass.eventEmitter) {
                 superclass.eventEmitter.on('initializationEnd', () => {
@@ -128,82 +80,32 @@ module.exports = ({
             return Reflect.construct(contextInstance.instanceExtendedSubclass[name], args)
         }
 
-        async getNestedUnit({ nestedUnitKey, controllerInstance = this, additionalChildNestedUnit = [], pathPointerKey = null}) {
+        async getNestedUnit({ nestedUnitKey, additionalChildNestedUnit = [], pathPointerKey = null}) {
             let nestedUnitInstance;
-            if(!(nestedUnitKey in controllerInstance.instance.nestedUnit)) {
-                if(this.instanceExtendedSubclass) {
-                    nestedUnitInstance = await this.callSubclass('NestedUnit', [nestedUnitKey])                    
-                    if(!debugExecuted) {
-                        controllerInstance = this.__proto__
-                        // console.log(controllerInstance)
-                        // console.log(nestedUnitInstance.__proto__.__proto__.__proto__)
-                        controllerInstance.AppInstance = this.AppInstance
-                        controllerInstance.instance = this.instance
-                        assert.strictEqual(controllerInstance, nestedUnitInstance.__proto__.__proto__.__proto__)
-                        debugExecuted = true
-                    }
-                    nestedUnitInstance.__proto__.__proto__.__proto__ = controllerInstance
-                } else {
-                    nestedUnitInstance = await self.callSubclass('NestedUnit', [nestedUnitKey])                    
-                    if(!debugExecuted) {
-                        controllerInstance = this.__proto__
-                        // console.log(controllerInstance)
-                        // console.log(nestedUnitInstance.__proto__.__proto__.__proto__)
-                        controllerInstance.AppInstance = this.AppInstance
-                        controllerInstance.instance = this.instance
-                        assert.strictEqual(controllerInstance, nestedUnitInstance.__proto__.__proto__.__proto__)
-                        debugExecuted = true
-                    }
-                    nestedUnitInstance.__proto__.__proto__.__proto__ = controllerInstance
-                }
+            if(!(nestedUnitKey in this.instance.nestedUnit)) {
+                nestedUnitInstance = await this.callSubclass('NestedUnit', [nestedUnitKey])
                 await nestedUnitInstance.initializeInstance()
+                console.log(nestedUnitInstance)
                 // add children trees: 
                 nestedUnitInstance.additionalChildNestedUnit = additionalChildNestedUnit
                 // add pathPointerKey to allow applying additional corresponding additional children.
                 nestedUnitInstance.pathPointerKey = pathPointerKey
                 // add to class cache
-                controllerInstance.instance.nestedUnit[nestedUnitKey] = nestedUnitInstance
+                this.instance.nestedUnit[nestedUnitKey] = nestedUnitInstance
             } else {
-                nestedUnitInstance = controllerInstance.instance.nestedUnit[nestedUnitKey]
+                nestedUnitInstance = this.instance.nestedUnit[nestedUnitKey]
             }
             return nestedUnitInstance
         }
 
-        async getUnit({unitKey, controllerInstance = this}) {
+        async getUnit({unitKey}) {
             let unitInstance;
-            if(!(unitKey in controllerInstance.instance.unit)) {
-                if(this.instanceExtendedSubclass) {
-                    unitInstance = await this.callSubclass('Unit', [unitKey])
-                    if(!debugEx2) {
-                        controllerInstance = this.__proto__
-                        // console.log(controllerInstance)
-                        // console.log(nestedUnitInstance.__proto__.__proto__.__proto__)
-                        controllerInstance.AppInstance = this.AppInstance
-                        controllerInstance.instance = this.instance
-                        assert.strictEqual(controllerInstance, unitInstance.__proto__.__proto__.__proto__)
-                        debugEx2 = true
-                    }
-                    // assert.strictEqual(unitInstance.__proto__.__proto__.__proto__, controllerInstance)
-                    unitInstance.__proto__.__proto__.__proto__ = controllerInstance
-                } else {
-                    unitInstance = await self.callSubclass('Unit', [unitKey])
-                    if(!debugEx2) {
-                        controllerInstance = this.__proto__
-                        // console.log(controllerInstance)
-                        // console.log(nestedUnitInstance.__proto__.__proto__.__proto__)
-                        controllerInstance.AppInstance = this.AppInstance
-                        controllerInstance.instance = this.instance
-                        assert.strictEqual(controllerInstance, unitInstance.__proto__.__proto__.__proto__)
-                        debugEx2 = true
-                    }
-                    // assert.strictEqual(unitInstance.__proto__.__proto__.__proto__, controllerInstance)
-                    unitInstance.__proto__.__proto__.__proto__ = controllerInstance
-                }
-                // console.log(unitInstance)
+            if(!(unitKey in this.instance.unit)) {
+                unitInstance = await this.callSubclass('Unit', [unitKey])
                 await unitInstance.initializeInstance()
-                controllerInstance.instance.unit[unitKey] = unitInstance
+                this.instance.unit[unitKey] = unitInstance
             } else {
-                unitInstance = controllerInstance.instance.unit[unitKey]
+                unitInstance = this.instance.unit[unitKey]
             }
             return unitInstance
         }