scoundrel-remote-eval 1.0.3 → 1.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "scoundrel-remote-eval",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "main": "src/index.js",
   "scripts": {

package/spec/reference-with-proxy-spec.js

@@ -37,4 +37,21 @@ describe("referenceWithProxy", () => {
 
     expect(result).toEqual(["test1", "test2"])
   })
+
+  it("reads attributes from a reference", async () => {
+    const testArray = await shared.client.newObjectWithReference("Array")
+
+    await testArray.callMethod("push", "test1")
+    await testArray.callMethod("push", "test2")
+
+    const result = await testArray.serialize()
+
+    expect(result).toEqual(["test1", "test2"])
+
+    const firstValue = await testArray.readAttribute(0)
+    const secondValue = await testArray.readAttribute(1)
+
+    expect(firstValue).toEqual("test1")
+    expect(secondValue).toEqual("test2")
+  })
 })

package/spec/web-socket-javascript-spec.js

@@ -35,4 +35,15 @@ describe("scoundrel - web-socket - javascript", () => {
 
     expect(result).toEqual(["test1", "test2"])
   })
+
+  it("returns results from method calls", async () => {
+    const stringObject = await shared.client.newObjectWithReference("Array")
+
+    await stringObject.callMethod("push", "test1")
+    await stringObject.callMethod("push", "test2")
+
+    const result = await stringObject.callMethod("join", ", ")
+
+    expect(result).toEqual("test1, test2")
+  })
 })

package/src/client/index.js

@@ -16,13 +16,15 @@ export default class Client {
   }
 
   async callMethodOnReference(referenceId, methodName, ...args) {
-    return await this.backend.send({
+    const result = await this.backend.send({
       args: this.parseArg(args),
       command: "call_method_on_reference",
       method_name: methodName,
       reference_id: referenceId,
       with: "result"
     })
+
+    return result.response
   }
 
   async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {
@@ -62,6 +64,19 @@ export default class Client {
     return this.spawnReference(id)
   }
 
+  async getObject(objectName) {
+    const result = await this.backend.send({
+      command: "get_object",
+      object_name: objectName
+    })
+
+    if (!result) throw new Error("Blank result given")
+
+    const id = result.object_id
+
+    return this.spawnReference(id)
+  }
+
   async newObjectWithReference(className, ...args) {
     const result = await this.backend.send({
       args: this.parseArg(args),
@@ -76,7 +91,7 @@ export default class Client {
     return this.spawnReference(id)
   }
 
-  isPlainObject = (input) => {
+  isPlainObject(input) {
     if (input && typeof input === "object" && !Array.isArray(input)) {
       return true
     }
@@ -119,6 +134,16 @@ export default class Client {
     return this.spawnReference(id)
   }
 
+  async readAttributeOnReference(referenceId, attributeName) {
+    const result = await this.backend.send({
+      command: "read_attribute",
+      attribute_name: attributeName,
+      reference_id: referenceId,
+      with: "result"
+    })
+    return result.response
+  }
+
   async serializeReference(referenceId) {
     const json = await this.backend.send({command: "serialize_reference", reference_id: referenceId})
 

package/src/client/reference.js

@@ -14,6 +14,10 @@ export default class Reference {
     return await this.client.callMethodOnReferenceWithReference(this.id, methodName, ...args)
   }
 
+  async readAttribute(attributeName, ...args) {
+    return await this.client.readAttributeOnReference(this.id, attributeName, ...args)
+  }
+
   async readAttributeWithReference(attributeName, ...args) {
     return await this.client.readAttributeOnReferenceWithReference(this.id, attributeName, ...args)
   }

package/src/server/client/index.js

@@ -9,9 +9,24 @@ export default class ServerClient {
 
   onCommand = (commandId, data) => {
     try {
-      if (data.command == "new_object_with_reference") {
-        const className = data.class_name
+      if (data.command == "get_object") {
+        const serverObject = this.server.getObject(data.object_name)
+        let object
+
+        if (serverObject) {
+          object = serverObject
+        } else {
+          object = global[data.object_name]
+
+          if (!object) throw new Error(`No such object: ${data.object_name}`)
+        }
+
         const objectId = ++this.objectsCount
+
+        this.objects[objectId] = object
+        this.respondToCommand(commandId, {object_id: objectId})
+      } else if (data.command == "new_object_with_reference") {
+        const className = data.class_name
         let object
 
         if (typeof className == "string") {
@@ -30,8 +45,9 @@ export default class ServerClient {
           throw new Error(`Don't know how to handle class name: ${typeof className}`)
         }
 
-        this.objects[objectId] = object
+        const objectId = ++this.objectsCount
 
+        this.objects[objectId] = object
         this.respondToCommand(commandId, {object_id: objectId})
       } else if (data.command == "call_method_on_reference") {
         const referenceId = data.reference_id
@@ -53,6 +69,24 @@ export default class ServerClient {
         if (!object) throw new Error(`No object by that ID: ${referenceId}`)
 
         this.respondToCommand(commandId, JSON.stringify(object))
+      } else if (data.command == "read_attribute") {
+        const attributeName = data.attribute_name
+        const referenceId = data.reference_id
+        const returnWith = data.with
+        const object = this.objects[referenceId]
+
+        if (!object) throw new Error(`No object by that ID: ${referenceId}`)
+
+        const attribute = object[attributeName]
+
+        if (returnWith == "reference") {
+          const objectId = ++this.objectsCount
+
+          this.objects[objectId] = attribute
+          this.respondToCommand(commandId, {response: objectId})
+        } else {
+          this.respondToCommand(commandId, {response: attribute})
+        }
       } else {
         this.clientBackend.send({type: "command_response", command_id: commandId, error: `Unknown command: ${data.command}`})
       }

package/src/server/index.js

@@ -6,9 +6,10 @@ export default class ScoundrelServer {
     this.backend.onNewClient(this.onNewClient)
     this.clients = []
     this._classes = {}
+    this._objects = {}
   }
 
-  close = () => this.backend.close()
+  close() { this.backend.close() }
 
   onNewClient = (clientBackend) => {
     const client = new Client(clientBackend, this)
@@ -22,7 +23,17 @@ export default class ScoundrelServer {
     this._classes[className] = classInstance
   }
 
+  registerObject(objectName, objectInstance) {
+    if (objectName in this._objects) throw new Error(`Object already exists: ${objectName}`)
+
+    this._objects[objectName] = objectInstance
+  }
+
   getClass(className) {
     return this._classes[className]
   }
+
+  getObject(objectName) {
+    return this._objects[objectName]
+  }
 }