Cant pass javascript functions between runtimes.

[silven]

Hello,

I've got a situation where I want multiple Otto runtimes and would like to pass functions between them to allow the runtimes to interact. But code like this doesn't work:

package main

import (
    "fmt"
    "github.com/robertkrimen/otto"
)

func main() {
    o1 := otto.New()
    o1.Run(`
        console.log("HI")
        exports = {}
        exports.tomte = function() {
            console.log("Tomte!")
            return 7
        }
    `)
    value, err := o1.Get("exports")
    if err != nil {
        fmt.Println("ERROR:", err)
        return
    }
    o2 := otto.New()
    o2.Set("exp", value)
    value, err = o2.Run(`
        console.log(exp.tomte)
    `)
    if err != nil {
        fmt.Println("ERROR:", err)
        return
    }
    fmt.Println("Bye bye Otto!")
}

Doesn't make the function in the first runtime to be visible in the second. I try passing the function itself, and in Go it has the "type" [function] but the second runtime can't run the code.

Is it at all possible to make functions travel across runtimes or how can I achieve interaction between different segments of independent code? Or some sort of observer pattern and event trigger system.

[robertkrimen]

Well, that's interesting, and kind of weird.

If you had this code in one runtime:

     var abc = 0;
     var fn = function() {
            abc += 1;
     }

What does it mean when you export fn to a different runtime and call it there? Does it increment abc in the original runtime? Does it try to increment abc in the new runtime? (edit: It should increment abc in the original runtime... probably.)

Maybe you can better explain what you're trying to do?

I'm not sure why the code is not running, I don't explicitly check for cross-runtime Object migration, though I probably should.

[silven]

I was trying to create a network of independent pieces of code, occasionally interacting with each other. My hope being that if I could export functions, that would affect code in it's origin runtime, I could define and extend the situation in pure javascript, without having to give hooks for every single function. This to create observer patterns and event triggering mechanics.

I hope that is enough of an explanation.

[robertkrimen]

Thanks for the report, this was actually a pretty substantial issue with the toValue method. Basically, the reflection stuff was treating a Value as a struct, turning it into a sort of nonsensical Object in the JavaScript runtime.

Your original code should work fine now.

Technically, I don't think there is anything wrong with an Object existing in more than one runtime at the same time. It would be costly to try and prevent anyway (deep introspection of every value passed to toValue, etc.).