func (ctrl *JsController) addDiscoveryService(o *otto.Otto) { o.Set("discover", func(call otto.FunctionCall) otto.Value { if len(call.ArgumentList) == 0 { glog.Errorf("DISCOVER: Missing arguments") return otto.NullValue() } url, _ := call.Argument(0).ToString() upstreams, err := ctrl.DiscoveryService.Get(url) if err != nil { glog.Errorf("Failed to discover upstreams: %v", err) return otto.NullValue() } glog.Infof("Discovered upstreams: %v", upstreams) result, err := o.ToValue(upstreams) if err != nil { glog.Errorf("Failed to convert: %v", err) return otto.NullValue() } return result }) }
func (p *pathObject) toValue(call otto.FunctionCall, withTags bool) otto.Value { it := p.buildIteratorTree() it.Tagger().Add(TopResultTag) const limit = 1 var ( val otto.Value err error ) if !withTags { array := p.wk.runIteratorToArrayNoTags(it, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } else { array := p.wk.runIteratorToArray(it, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } if err != nil { glog.Error(err) return otto.NullValue() } return val }
// pipelines in javascript are chainable, you take in a pipeline, and you return a pipeline // we just generalize some of that logic here func (js *JavascriptBuilder) setFunc(obj *otto.Object, token string, fn func(string, Node, otto.FunctionCall) (Node, error)) error { return obj.Set(token, func(call otto.FunctionCall) otto.Value { this, _ := call.This.Export() node, err := CreateNode(this) if err != nil { js.err = err return otto.NullValue() } node, err = fn(token, node, call) if err != nil { js.err = err return otto.NullValue() } o, err := node.Object() if err != nil { js.err = err return otto.NullValue() } js.setFunc(o, "transform", js.transform) js.setFunc(o, "save", js.save) return o.Value() }) }
func (wk *worker) toValueFunc(env *otto.Otto, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value { return func(call otto.FunctionCall) otto.Value { it := buildIteratorTree(obj, wk.qs) it.Tagger().Add(TopResultTag) limit := 1 var val otto.Value var err error if !withTags { array := wk.runIteratorToArrayNoTags(it, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } else { array := wk.runIteratorToArray(it, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } if err != nil { clog.Errorf("%v", err) return otto.NullValue() } return val } }
func (p *pathObject) has(call otto.FunctionCall, rev bool) otto.Value { args := exportArgs(call.ArgumentList) if len(args) == 0 { return otto.NullValue() } via := args[0] if vp, ok := via.(*pathObject); ok { via = vp.path } else { via, ok = toQuadValue(via) if !ok { return otto.NullValue() } } qv, err := toQuadValues(args[1:]) if err != nil { //TODO(dennwc): pass error to caller return otto.NullValue() } np := p.clonePath() if rev { np = np.HasReverse(via, qv...) } else { np = np.Has(via, qv...) } return outObj(call, p.new(np)) }
func (p *pathObject) save(call otto.FunctionCall, rev bool) otto.Value { args := exportArgs(call.ArgumentList) if len(args) > 2 || len(args) == 0 { return otto.NullValue() } vtag := args[0] if len(args) == 2 { vtag = args[1] } tag, ok := vtag.(string) if !ok { return otto.NullValue() } via := args[0] if vp, ok := via.(*pathObject); ok { via = vp.path } else { via, ok = toQuadValue(via) if !ok { return otto.NullValue() } } np := p.clonePath() if rev { np = np.SaveReverse(via, tag) } else { np = np.Save(via, tag) } return outObj(call, p.new(np)) }
func convertNilsToNulls(object interface{}) { switch object := object.(type) { case map[string]interface{}: for key, obj := range object { switch obj := obj.(type) { case map[string]interface{}: convertNilsToNulls(obj) case []interface{}: convertNilsToNulls(obj) case nil: object[key] = otto.NullValue() } } case []interface{}: for key, obj := range object { switch obj := obj.(type) { case map[string]interface{}: convertNilsToNulls(obj) case []interface{}: convertNilsToNulls(obj) case nil: object[key] = otto.NullValue() } } } }
func (p *pathObject) toArray(call otto.FunctionCall, withTags bool) otto.Value { args := exportArgs(call.ArgumentList) if len(args) != 1 { return otto.NullValue() } limit := -1 if len(args) > 0 { limit = toInt(args[0]) } it := p.buildIteratorTree() it.Tagger().Add(TopResultTag) var ( val otto.Value err error ) if !withTags { array := p.wk.runIteratorToArrayNoTags(it, limit) val, err = call.Otto.ToValue(array) } else { array := p.wk.runIteratorToArray(it, limit) val, err = call.Otto.ToValue(array) } if err != nil { glog.Error(err) return otto.NullValue() } return val }
func toValueFunc(env *otto.Otto, ses *Session, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value { return func(call otto.FunctionCall) otto.Value { it := buildIteratorTree(obj, ses.ts) it.Tagger().Add(TopResultTag) limit := 1 var val otto.Value var err error if !withTags { array := runIteratorToArrayNoTags(it, ses, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } else { array := runIteratorToArray(it, ses, limit) if len(array) < 1 { return otto.NullValue() } val, err = call.Otto.ToValue(array[0]) } if err != nil { glog.Error(err) return otto.NullValue() } else { return val } } }
func cmpOpType(op iterator.Operator) func(call otto.FunctionCall) otto.Value { return func(call otto.FunctionCall) otto.Value { args := exportArgs(call.ArgumentList) if len(args) != 1 { return otto.NullValue() } qv, ok := toQuadValue(args[0]) if !ok { return otto.NullValue() } return outObj(call, cmpOperator{op: op, val: qv}) } }
func (j *job) runCompScript(irs [][]*gnr.InteractionResult) { vm := otto.New() injectRuntime(vm) if err := vm.Set("interactions", irs); err != nil { panic(err) } vm.Set("width", Width) vm.Set("height", Height) compositions := make([]composition, 0, 5) vm.Set("composition", func(call otto.FunctionCall) otto.Value { name, err := call.Argument(0).ToString() if err != nil { panic("First argument to composition() must be a string") } cb := call.Argument(1) if !cb.IsFunction() { panic("Second argument to composition() must be a function(x,y)") } compositions = append(compositions, composition{name, cb}) return otto.NullValue() }) if _, err := vm.Run(j.Composite); err != nil { panic(err) } for _, comp := range compositions { img := image.NewRGBA(image.Rect(0, 0, Width, Height)) for y := 0; y < Height; y++ { for x := 0; x < Width; x++ { v, err := comp.Func.Call(otto.NullValue(), x, y) if err != nil { panic(err) } c, err := v.Export() if err != nil { panic(err) } img.Set(x, y, mapToColor(c.(map[string]interface{}))) } } buf := &bytes.Buffer{} if err := png.Encode(buf, img); err != nil { panic(err) } j.Compositions[comp.Name] = buf.Bytes() } }
func reverseGremlinChainTo(env *otto.Otto, prevObj *otto.Object, tag string) (*otto.Object, *otto.Object) { env.Run("var _base_object = {}") base, err := env.Object("_base_object") if err != nil { glog.Error(err) return otto.NullValue().Object(), otto.NullValue().Object() } if isVertexChain(prevObj) { base.Set("_gremlin_type", "vertex") } else { base.Set("_gremlin_type", "morphism") } return reverseGremlinChainHelper(env, prevObj, base, tag) }
func (p *pathObject) ForEach(call otto.FunctionCall) otto.Value { it := p.buildIteratorTree() it.Tagger().Add(TopResultTag) limit := -1 if len(call.ArgumentList) == 0 { return otto.NullValue() } callback := call.Argument(len(call.ArgumentList) - 1) args := exportArgs(call.ArgumentList[:len(call.ArgumentList)-1]) if len(args) > 1 { limit = toInt(args[0]) } p.wk.runIteratorWithCallback(it, callback, call, limit) return otto.NullValue() }
func (p *pathObject) Filter(call otto.FunctionCall) otto.Value { args := exportArgs(call.ArgumentList) if len(args) == 0 { return otto.NullValue() } np := p.clonePath() for _, arg := range args { op, ok := arg.(cmpOperator) if !ok { return otto.NullValue() } np = np.Filter(op.op, op.val) } return outObj(call, p.new(np)) }
// Invokes the JS function. Not thread-safe! This is exposed for use by unit tests. func (server *JSServer) DirectCallFunction(inputs []string) (interface{}, error) { if server.Before != nil { server.Before() } var result otto.Value var err error if server.fn.IsUndefined() { result = otto.UndefinedValue() } else { inputJS := make([]interface{}, len(inputs)) for i, inputStr := range inputs { if inputStr == "" { inputJS[i] = otto.NullValue() } else { var err error inputJS[i], err = server.js.Object("x = " + inputStr) if err != nil { return nil, fmt.Errorf("Unparseable input %q: %s", inputStr, err) } } } result, err = server.fn.Call(server.fn, inputJS...) } if server.After != nil { return server.After(result, err) } return nil, err }
func Worker(lines, out chan *string, script, preload string, wg *sync.WaitGroup) { defer wg.Done() vm := otto.New() if preload != "" { _, err := vm.Run(preload) if err != nil { log.Fatal(err) } } compiled, err := vm.Compile("", script) if err != nil { log.Fatal(err) } for line := range lines { vm.Set("input", *line) _, err := vm.Run(compiled) if err != nil { log.Fatal(err) } result, err := vm.Get("output") if result == otto.NullValue() { continue } if err != nil { log.Fatal(err) } r := result.String() out <- &r } }
// SpawnPrefab is an otto function that takes three arguments, a string and two integer. This spawns an object. // The string is the name of the prefab, while the int arguments are X and Y coords, respectively. func (api *EngineInterface) SpawnPrefab(call otto.FunctionCall) otto.Value { prefabName, err := call.Argument(0).ToString() if err != nil { gLogger.Fatalln(err) } x, err := call.Argument(1).ToInteger() if err != nil { gLogger.Fatalln(err) } y, err := call.Argument(2).ToInteger() if err != nil { gLogger.Fatalln(err) } prefab := api.base.Prefabs().Prefab(prefabName) if prefab == nil { gLogger.Fatalln("Prefab", prefabName, "doesn't exit") } // api is a bit dirty don't you think? cords := prefab.Component(new(TransformComponent)).(*TransformComponent) cords.X = int32(x) cords.Y = int32(y) return otto.NullValue() }
func (rc *RunContext) End(call otto.FunctionCall) otto.Value { log.Println("END OTTO") go func() { rc.EndChan <- true }() return otto.NullValue() }
func (t *fetchTask) Execute(vm *otto.Otto, l *loop.Loop) error { var arguments []interface{} if t.err != nil { e, err := vm.Call(`new Error`, nil, t.err.Error()) if err != nil { return err } arguments = append(arguments, e) } t.jsRes.Set("status", t.status) t.jsRes.Set("statusText", t.statusText) h := mustValue(t.jsRes.Get("headers")).Object() for k, vs := range t.headers { for _, v := range vs { if _, err := h.Call("append", k, v); err != nil { return err } } } t.jsRes.Set("_body", string(t.body)) if _, err := t.cb.Call(otto.NullValue(), arguments...); err != nil { return err } return nil }
func (rc *RunContext) SendMail(call otto.FunctionCall) otto.Value { if len(call.ArgumentList) < 3 { return rc.Err("sendMail called with too few parameters") } to, err := call.ArgumentList[0].ToString() if err != nil { return rc.Err(err.Error()) } subject, err := call.ArgumentList[1].ToString() if err != nil { return rc.Err(err.Error()) } body, err := call.ArgumentList[2].ToString() if err != nil { return rc.Err(err.Error()) } rc.runner.Mailer.SendMailSimple(to, subject, body) return otto.NullValue() }
func (p *pathObject) GetLimit(call otto.FunctionCall) otto.Value { args := exportArgs(call.ArgumentList) if len(args) != 1 { return otto.NullValue() } return p.getLimit(toInt(args[0])) }
func toArrayFunc(env *otto.Otto, ses *Session, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value { return func(call otto.FunctionCall) otto.Value { it := buildIteratorTree(obj, ses.ts) it.Tagger().Add(TopResultTag) limit := -1 if len(call.ArgumentList) > 0 { limitParsed, _ := call.Argument(0).ToInteger() limit = int(limitParsed) } var val otto.Value var err error if !withTags { array := runIteratorToArrayNoTags(it, ses, limit) val, err = call.Otto.ToValue(array) } else { array := runIteratorToArray(it, ses, limit) val, err = call.Otto.ToValue(array) } if err != nil { glog.Error(err) return otto.NullValue() } return val } }
func mapFunc(env *otto.Otto, ses *Session, obj *otto.Object) func(otto.FunctionCall) otto.Value { return func(call otto.FunctionCall) otto.Value { it := buildIteratorTree(obj, ses.ts) it.Tagger().Add(TopResultTag) limit := -1 if len(call.ArgumentList) == 0 { return otto.NullValue() } callback := call.Argument(len(call.ArgumentList) - 1) if len(call.ArgumentList) > 1 { limitParsed, _ := call.Argument(0).ToInteger() limit = int(limitParsed) } runIteratorWithCallback(it, ses, callback, call, limit) return otto.NullValue() } }
func (p *pathObject) Back(call otto.FunctionCall) otto.Value { args := toStrings(exportArgs(call.ArgumentList)) if len(args) != 1 { return otto.NullValue() } np := p.clonePath().Back(args[0]) return outObj(call, p.new(np)) }
func (p *pathObject) Both(call otto.FunctionCall) otto.Value { preds, _, ok := toViaData(exportArgs(call.ArgumentList)) if !ok { return otto.NullValue() } np := p.clonePath().Both(preds...) return outObj(call, p.new(np)) }
func (p *pathObject) LabelContext(call otto.FunctionCall) otto.Value { labels, tags, ok := toViaData(exportArgs(call.ArgumentList)) if !ok { return otto.NullValue() } np := p.clonePath().LabelContextWithTags(tags, labels...) return outObj(call, p.new(np)) }
func (p *pathObject) Except(call otto.FunctionCall) otto.Value { ep, ok := exportAsPath(call.ArgumentList) if !ok { return otto.NullValue() } np := p.clonePath().Except(ep.path) return outObj(call, p.new(np)) }
func (p *pathObject) getLimit(limit int) otto.Value { it := p.buildIteratorTree() it.Tagger().Add(TopResultTag) p.wk.limit = limit p.wk.count = 0 p.wk.runIterator(it) return otto.NullValue() }
func (p *pathObject) Is(call otto.FunctionCall) otto.Value { args, err := toQuadValues(exportArgs(call.ArgumentList)) if err != nil { //TODO(dennwc): pass error to caller return otto.NullValue() } np := p.clonePath().Is(args...) return outObj(call, p.new(np)) }
func newError(o *otto.Otto, inError error) otto.Value { obj := errorToJs(inError) jsObj, err := o.ToValue(obj) if err != nil { glog.Errorf("Error: %s", err) return otto.NullValue() } return jsObj }