Exemplo n.º 1
0
func NewOttoGrouper() *OttoGrouper {
	return &OttoGrouper{
		OutputChannel: make(DocumentChannel),
		Otto:          otto.New(),
		groupValues:   make(map[string]ExpressionStatsMap),
		groupDocs:     make(map[string]Document)}
}
Exemplo n.º 2
0
func main() {
	flag.Parse()
	var script []byte
	var err error
	filename := flag.Arg(0)
	if filename == "" || filename == "-" {
		script, err = ioutil.ReadAll(os.Stdin)
		if err != nil {
			fmt.Printf("Can't read stdin: %v\n", err)
			os.Exit(64)
		}
	} else {
		script, err = ioutil.ReadFile(filename)
		if err != nil {
			fmt.Printf("Can't open file \"%v\": %v\n", filename, err)
			os.Exit(64)
		}
	}
	if !*underscoreFlag {
		underscore.Disable()
	}
	Otto := otto.New()
	_, err = Otto.Run(string(script))
	if err != nil {
		fmt.Println(err)
		os.Exit(64)
	}
}
Exemplo n.º 3
0
func initJs(t *testing.T) *otto.Otto {
	var otto = otto.New()
	soyutilsFile, err := os.Open("lib/soyutils.js")
	if err != nil {
		panic(err)
	}
	// remove any non-otto compatible regular expressions
	var soyutilsBuf bytes.Buffer
	var scanner = bufio.NewScanner(soyutilsFile)
	var i = 1
	for scanner.Scan() {
		switch i {
		case 2565, 2579, 2586:
			// skip these regexes
			// soy.esc.$$FILTER_FOR_FILTER_CSS_VALUE_
			// soy.esc.$$FILTER_FOR_FILTER_HTML_ATTRIBUTES_
			// soy.esc.$$FILTER_FOR_FILTER_HTML_ELEMENT_NAME_
		default:
			soyutilsBuf.Write(scanner.Bytes())
			soyutilsBuf.Write([]byte("\n"))
		}
		i++
	}
	// load the soyutils library
	_, err = otto.Run(soyutilsBuf.String())
	if err != nil {
		t.Errorf("soyutils error: %v", err)
		panic(err)
	}
	return otto
}
Exemplo n.º 4
0
func Calculate(response http.ResponseWriter, request *http.Request, params martini.Params) {
	bodyBytes, err := ioutil.ReadAll(request.Body)
	if err != nil {
		return
	}

	var toCalc Calculation
	err = json.Unmarshal(bodyBytes, &toCalc)
	if err != nil {
		http.Error(response, "Failed to Parse JSON", http.StatusInternalServerError)
		return
	}
	if toCalc.Calculation == "" {
		return
	}
	runner := otto.New()
	result, err := runner.Run(toCalc.Calculation)
	if err != nil {
		http.Error(response, err.Error(), http.StatusInternalServerError)
		return
	}
	toCalc.Result, _ = result.ToFloat()
	responseBytes, err := json.Marshal(toCalc)
	if err != nil {
		http.Error(response, "Failed to Encode JSON", http.StatusInternalServerError)
		return
	}

	fmt.Fprint(response, string(responseBytes))
	return
}
Exemplo n.º 5
0
func NewScripting() (s *Scripting, err error) {
	s = &Scripting{
		vm:        otto.New(),
		listeners: map[string][]otto.Value{},
	}
	return
}
Exemplo n.º 6
0
// NewJavascriptBuilder compiles the supplied javascript and creates a Javascriptbulder
func NewJavascriptBuilder(config Config, file, src string) (*JavascriptBuilder, error) {
	js := &JavascriptBuilder{
		file:      file,
		vm:        otto.New(),
		path:      filepath.Dir(file),
		config:    config,
		nodes:     make(map[string]Node),
		pipelines: make([]*transporter.Pipeline, 0),
	}

	var (
		script *otto.Script
		err    error
	)
	if src != "" {
		script, err = js.vm.Compile("", src)
	} else {
		script, err = js.vm.Compile(file, nil)
	}

	if err != nil {
		return js, err
	}
	js.script = script
	js.vm.Set("Source", js.source)

	return js, nil
}
Exemplo n.º 7
0
func NewChannelMapper(funcSource string) (*ChannelMapper, error) {
	mapper := &ChannelMapper{}
	mapper.js = otto.New()

	// Implementation of the 'sync()' callback:
	mapper.js.Set("sync", func(call otto.FunctionCall) otto.Value {
		for _, arg := range call.ArgumentList {
			if arg.IsString() {
				mapper.channels = append(mapper.channels, arg.String())
			} else if arg.Class() == "Array" {
				array := ottoArrayToStrings(arg.Object())
				if array != nil {
					mapper.channels = append(mapper.channels, array...)
				}
			}
		}
		return otto.UndefinedValue()
	})

	if _, err := mapper.setFunction(funcSource); err != nil {
		return nil, err
	}

	mapper.requests = make(chan channelMapperRequest)
	go mapper.serve()

	return mapper, nil
}
Exemplo n.º 8
0
func TestFetchWithHandlerParallel(t *testing.T) {
	m := http.NewServeMux()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello"))
	})

	vm := otto.New()
	l := loop.New(vm)

	if err := DefineWithHandler(vm, l, m); err != nil {
		panic(err)
	}

	ch := make(chan bool, 1)

	if err := vm.Set("__capture", func(c otto.FunctionCall) otto.Value {
		defer func() { ch <- true }()

		return otto.UndefinedValue()
	}); err != nil {
		panic(err)
	}

	must(l.EvalAndRun(`Promise.all([1,2,3,4,5].map(function(i) { return fetch('/' + i); })).then(__capture)`))

	<-ch
}
Exemplo n.º 9
0
func TestOttoFromGoArray(t *testing.T) {
	o := otto.New()
	_, err := OttoFromGoArray(o, nil)
	if err == nil {
		t.Errorf("expected err for nil array to OttoFromGoArray")
	}
}
Exemplo n.º 10
0
// NewAnnotator returns an Annotator with the sources, seeded with some javascript.
// If ends is true, it will annotate the 1 base ends of the interval as well as the
// interval itself. If strict is true, when overlapping variants, they must share
// the ref allele and at least 1 alt allele.
func NewAnnotator(sources []*Source, js string, ends bool, strict bool) *Annotator {
	for _, s := range sources {
		if e := checkSource(s); e != nil {
			log.Fatal(e)
		}
	}
	a := Annotator{
		Sources: sources,
		Strict:  strict,
		Ends:    ends,
	}
	for _, src := range a.Sources {
		src.Vm = otto.New() // create a new vm for each source and lock in the source
		if strings.HasPrefix(src.Op, "js:") {
			var err error
			src.Js, err = src.Vm.Compile(src.Op, src.Op[3:])
			if err != nil {
				log.Fatalf("error parsing op: %s for file %s", src.Op, src.File)
			}
		}
		if js != "" {
			_, err := src.Vm.Run(js)
			if err != nil {
				log.Fatalf("error parsing customjs:%s", err)
			}
		}
	}
	return &a
}
Exemplo n.º 11
0
func main() {
	flag.Parse()

	if !*flag_underscore {
		underscore.Disable()
	}

	err := func() error {
		src, err := readSource(flag.Arg(0))
		if err != nil {
			return err
		}

		vm := otto.New()
		g_vm = vm

		vm.Set("setRoute", setRoute)
		vm.Set("startServer", startServer)
		vm.Set("writeMessage", writeMessage)

		_, err = vm.Run(src)
		return err
	}()
	if err != nil {
		switch err := err.(type) {
		case *otto.Error:
			fmt.Print(err.String())
		default:
			fmt.Println(err)
		}
		os.Exit(64)
	}
}
Exemplo n.º 12
0
func createVM() *otto.Otto {
	vm := otto.New()

	logObj, _ := vm.Object(`$log = {}`)
	logObj.Set("info", _log_info)

	fileObj, _ := vm.Object(`$file = {}`)
	fileObj.Set("exists", _file_exists)
	fileObj.Set("write", _file_write)
	fileObj.Set("copy", _file_copy)
	fileObj.Set("size", _file_size)
	fileObj.Set("move", _file_move)
	fileObj.Set("mkdir", _file_mkdir)
	fileObj.Set("delete", _file_delete)
	fileObj.Set("readString", _file_readString)

	requestObj, _ := vm.Object(`$request = {}`)
	requestObj.Set("download", _request_download)
	requestObj.Set("get", _request_get)

	systemObj, _ := vm.Object(`$system = {}`)
	systemObj.Set("executeAndRead", _system_executeAndRead)
	systemObj.Set("execute", _system_execute)
	systemObj.Set("detach", _system_detach)
	systemObj.Set("currentUser", _system_currentUser)
	systemObj.Set("kill", _system_kill)

	return vm
}
Exemplo n.º 13
0
func main() {

	vm := otto.New()

	s, _ := simplejson.NewJson([]byte(`
	{"name":"[{\"name\":\"全部\",\"value\":\"all\"},{\"value\":372,\"name\":\"家居个护\"},{\"value\":437,\"name\":\"美容彩妆\"},{\"value\":438,\"name\":\"母婴\"},{\"value\":440,\"name\":\"数码家电\"},{\"value\":636,\"name\":\"【多余类目\"},{\"value\":836,\"name\":\"环球美食\"},{\"value\":837,\"name\":\"营养保健\"},{\"value\":1025,\"name\":\"箱包配饰\"},{\"value\":7578,\"name\":\"运动户外\"},{\"value\":8115,\"name\":\"生鲜\"},{\"value\":9691,\"name\":\"服装鞋靴\"}]"}
	`))
	//fmt.Println(s.Get("name").MustMap())
	vm.Set("def", s.Get("name").MustString())
	vm.Set("getArray", func(call otto.FunctionCall) otto.Value {
		result, _ := vm.ToValue(getArray(call.Argument(0).String(), call.Argument(1).String()))
		return result
	})
	vm.Set("getMap", func(call otto.FunctionCall) otto.Value {
		result, _ := vm.ToValue(getMap(call.Argument(0).String(), call.Argument(1).String()))
		return result
	})
	_, e := vm.Run(`
	//var x = [];
	//x=x.concat(eval(def))
	//	console.log(x[0].name)
		//console.log(x.push(1))
		//var x = {category_level:1};
    		//var x = JSON.parse(getData('http://localhost:8080/ds/50',JSON.stringify({name:1,age:19})));
    		//console.log(x.data)
    		//console.log(x.code)
    		console.log(getArray('http://www.jeasyui.com/demo/main/treegrid_data1.json')[0].id)
	`)
	if e != nil {
		fmt.Println(e)
	}
}
Exemplo n.º 14
0
func TestNewReader_ReadAll(t *testing.T) {

	runtime := otto.New()
	reader := strings.NewReader("Hello ottox!")

	assert.NoError(t, NewReader(runtime, "read", reader))

	// make sure ottox.read method was added
	assert.True(t, Exist(runtime, "read"))

	// read some bytes
	if r, err := runtime.Call(`read`, nil, -1); assert.NoError(t, err) {
		if res, err := r.Object().Get("data"); assert.NoError(t, err) {
			if bytes, err := res.ToString(); assert.NoError(t, err) {
				assert.Equal(t, bytes, "Hello ottox!", "data")
			}
		}
		if res, err := r.Object().Get("eof"); assert.NoError(t, err) {
			if eofBool, err := res.ToBoolean(); assert.NoError(t, err) {
				assert.True(t, eofBool, "eof")
			}
		}
	}

}
Exemplo n.º 15
0
func HTTPMiddlewarePreRequest(endpoint *kasi_conf.EndpointSetting, r *http.Request) *MiddlewareResponse {
	for i := 0; i < len(endpoint.Middleware); i++ {
		jsFile, err := ioutil.ReadFile(endpoint.Middleware[i])
		if err != nil {
			log.Error("javascript file, `%v`, not found", i)
			continue
		}
		vm := otto.New()
		vm.Run(jsFile)

		request := *r
		requestJS, _ := vm.ToValue(&request)

		response := MiddlewareResponse{StatusCode: 0, Header: map[string]string{}, Body: ""}
		responseJS, _ := vm.ToValue(&response)

		returnedResponse, err := vm.Call("process_request", nil, requestJS, responseJS)
		if err != nil {
			log.Error("failed to call, %v", err)
			continue
		}

		if !returnedResponse.IsDefined() {
			continue
		}

		exportedResponseReady, err := returnedResponse.Export()
		if err == nil {
			return exportedResponseReady.(*MiddlewareResponse)
		}
		break
	}

	return nil
}
Exemplo n.º 16
0
func main() {
	flag.Parse()

	if !*flag_underscore {
		underscore.Disable()
	}

	err := func() error {
		src, err := readSource(flag.Arg(0))
		if err != nil {
			return err
		}

		vm := otto.New()
		_, err = vm.Run(src)
		return err
	}()
	if err != nil {
		switch err := err.(type) {
		case *otto.Error:
			fmt.Print(err.String())
		default:
			fmt.Println(err)
		}
		os.Exit(64)
	}
}
Exemplo n.º 17
0
func TestNewWriter(t *testing.T) {

	runtime := otto.New()
	var buf bytes.Buffer

	assert.NoError(t, NewWriter(runtime, "write", &buf))

	// make sure ottox.read method was added
	assert.True(t, Exist(runtime, "write"))

	if r, err := runtime.Call(`write`, nil, "abcde"); assert.NoError(t, err) {
		if res, err := r.Object().Get("len"); assert.NoError(t, err) {
			if lenInt, err := res.ToInteger(); assert.NoError(t, err) {
				assert.Equal(t, 5, lenInt, "len")
				assert.Equal(t, "abcde", buf.String())
			}
		}
	}

	if r, err := runtime.Call(`write`, nil, "fghij"); assert.NoError(t, err) {
		if res, err := r.Object().Get("len"); assert.NoError(t, err) {
			if lenInt, err := res.ToInteger(); assert.NoError(t, err) {
				assert.Equal(t, 5, lenInt, "len")
				assert.Equal(t, "abcdefghij", buf.String())
			}
		}
	}

}
Exemplo n.º 18
0
func initJavascript() {
	js = otto.New()

	f := facts.FindFacts()
	// TODO: log error
	factsAsJson, err := f.ToJson()
	if err == nil {
		js.Object(`facts = ` + string(factsAsJson))
	}

	// Create javascript functions
	js.Set("directory", directory)
	js.Set("symlink", symlink)
	js.Set("template", template)
	js.Set("apt", apt)
	js.Set("yum", yum)
	js.Set("command", command)
	js.Set("user", user)
	js.Set("pg_user", pgUser)
	js.Set("pg_database", pgDatabase)
	js.Set("mysql_user", mysqlUser)
	js.Set("mysql_database", mysqlDatabase)
	js.Set("sleep", sleep)
	js.Set("upstart", upstart)
	js.Set("file", file)
	js.Set("include", include)
}
Exemplo n.º 19
0
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
	}
}
Exemplo n.º 20
0
func TestFetchWithHandler(t *testing.T) {
	m := http.NewServeMux()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// these spaces are here so we can disambiguate between this and the
		// re-encoded data the javascript below spits out
		w.Write([]byte("[ 1 , 2 , 3 ]"))
	})

	vm := otto.New()
	l := loop.New(vm)

	if err := DefineWithHandler(vm, l, m); err != nil {
		panic(err)
	}

	ch := make(chan bool, 1)

	if err := vm.Set("__capture", func(s string) {
		defer func() { ch <- true }()

		if s != `[1,2,3]` {
			panic(fmt.Errorf("expected data to be json, and for that json to be parsed"))
		}
	}); err != nil {
		panic(err)
	}

	must(l.EvalAndRun(`fetch('/').then(function(r) { return r.json(); }).then(function(d) {
    return setTimeout(__capture, 4, JSON.stringify(d));
  })`))

	<-ch
}
Exemplo n.º 21
0
// Start running the JavaScript engine.
func (w *JavaScript) Run() {
	if cmd, ok := <-w.Cmd; ok {
		// initial setup
		engine := otto.New()

		// define a callback for sending messages to Out
		engine.Set("emitOut", func(call otto.FunctionCall) otto.Value {
			out, err := call.Argument(0).Export()
			flow.Check(err)
			w.Out.Send(out)
			return otto.UndefinedValue()
		})

		// process the command input
		if _, err := engine.Run(cmd.(string)); err != nil {
			glog.Fatal(err)
		}

		// only start the processing loop if the "onIn" handler exists
		value, err := engine.Get("onIn")
		if err == nil && value.IsFunction() {
			for in := range w.In {
				engine.Call("onIn", nil, in)
			}
		}
	}
}
Exemplo n.º 22
0
func TestFetchCallback(t *testing.T) {
	m := http.NewServeMux()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello"))
	})
	s := httptest.NewServer(m)
	defer s.Close()

	vm := otto.New()
	l := loop.New(vm)

	if err := Define(vm, l); err != nil {
		panic(err)
	}

	ch := make(chan bool, 1)

	if err := vm.Set("__capture", func(s string) {
		defer func() { ch <- true }()

		if !strings.Contains(s, "hello") {
			panic(fmt.Errorf("expected to find `hello' in response"))
		}
	}); err != nil {
		panic(err)
	}

	must(l.EvalAndRun(`fetch('` + s.URL + `').then(function(r) {
    return r.text();
  }).then(__capture)`))

	<-ch
}
Exemplo n.º 23
0
func newReducer() *otto.Otto {
	o := otto.New()
	must(o.Set("_sum", javascriptReduceSum))
	must(o.Set("_count", javascriptReduceCount))
	must(o.Set("_stats", javascriptReduceStats))
	return o
}
Exemplo n.º 24
0
func newRenderer(files []string) *renderer {
	r := &renderer{otto.New()}
	r.runFile("assets/global.js")
	r.runFile("assets/react.js")
	r.runFiles(files)
	return r
}
Exemplo n.º 25
0
func RunScript(file string) (conquest *Conquest, err error) {
	defer func() {
		if r := recover(); r != nil {
			switch r.(type) {
			case error:
				err = r.(error)
			case string:
				err = errors.New(r.(string))
			}
		}
	}()
	vm := otto.New()

	conjs := JSConquest{
		vm:       vm,
		conquest: NewConquest(),
	}

	if err = vm.Set("conquest", conjs); err != nil {
		return
	}

	script, err := vm.Compile(file, nil)
	if err != nil {
		return
	}

	_, err = vm.Run(script)
	if err != nil {
		return
	}
	conquest = conjs.conquest
	return
}
Exemplo n.º 26
0
// New is the constructor for a new engine.
func New(root, conditions string) (*Engine, error) {
	hostname, err := os.Hostname()
	if err != nil {
		return nil, err
	}

	engine := &Engine{Root: root, Hostname: hostname}

	if _, err := os.Stat(path.Join(engine.Root, "logic")); err == nil {
		logic, err := ioutil.ReadDir(path.Join(engine.Root, "logic"))
		if err != nil {
			return nil, err
		}
		engine.Logic = logic
	}

	if _, err := os.Stat(path.Join(engine.Root, "stacks")); err == nil {
		stacks, err := ioutil.ReadDir(path.Join(engine.Root, "stacks"))
		if err != nil {
			return nil, err
		}

		engine.Stacks = stacks
	}

	engine.DryRun = true
	engine.PythonPath = "python"
	engine.PipPath = "pip"
	engine.jsVM = otto.New()

	engine.SetConditions(conditions)

	return engine, nil
}
Exemplo n.º 27
0
Arquivo: JSUtil.go Projeto: v0l/gobot
func (*JSUtil) RunJS(e *irc.Event) {
	var halt = errors.New("Stahp")

	defer func() {
		if caught := recover(); caught != nil {
			if caught == halt {
				e.Connection.Privmsgf(e.Arguments[0], "!! WTF STAHP %s !!", e.Nick)
				return
			}
		}
	}()

	q := strings.TrimSpace(strings.Replace(e.Arguments[1], "!js ", "", -1))
	vm := otto.New()
	vm.Interrupt = make(chan func(), 1) // The buffer prevents blocking
	go func() {
		time.Sleep(10 * time.Second) // Stop after two seconds
		vm.Interrupt <- func() {
			panic(halt)
		}
	}()

	script, ser := vm.Compile("", q)
	if ser == nil {
		outjs, er := vm.Run(script)
		if er == nil {
			e.Connection.Privmsgf(e.Arguments[0], "[%s]: %s", e.Nick, outjs)
		} else {
			e.Connection.Privmsgf(e.Arguments[0], "Error in JS %s: %s", e.Nick, er)
		}
	} else {
		e.Connection.Privmsgf(e.Arguments[0], "Compile error %s: %s", e.Nick, ser)
	}
}
Exemplo n.º 28
0
Arquivo: otto.go Projeto: hattya/aster
func newVM() *otto.Otto {
	vm := otto.New()
	// os object
	os, _ := vm.Object(`os = {}`)
	os.Set("getwd", os_getwd)
	os.Set("mkdir", os_mkdir)
	os.Set("remove", os_remove)
	os.Set("rename", os_rename)
	os.Set("stat", os_stat)
	os.Set("system", os_system)
	os.Set("whence", os_whence)

	vm.Run(fmt.Sprintf(`os.FileInfo = function(name, size, mode, mtime) {
  this.name = name;
  this.size = size;
  this.mode = mode;
  this.mtime = mtime;
};

os.FileInfo.prototype.isDir = function() {
  return (this.mode & %v) !== 0;
};

os.FileInfo.prototype.isRegular = function() {
  return (this.mode & %v) === 0;
};

os.FileInfo.prototype.perm = function() {
  return this.mode & %v;
};
`, int64(1<<31), int64(0xff<<24), 0777))

	return vm
}
Exemplo n.º 29
0
func NewJSRuntime() (*JsVm, error) {
	vm := otto.New()
	jsvm := NewJsVm(vm)
	RegisterModules(jsvm)
	path := defaultPath

	fileC, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, err
	}
	/*
		fileHash := md5.Sum(fileC)
		if len(lastMd5) == 0 || lastMd5 != fileHash {
			lastMd5 = fileHash
			fmt.Println("compiling")
			compiled, err = vm.Compile(path, nil)
			if err != nil {
				return nil, err
			}
		}
		_, err = vm.Run(compiled)
	*/

	_, err = jsvm.Run(string(fileC))

	if err == nil {
		UsedRuntimes += 1
		fmt.Println("used runtimes " + strconv.Itoa(UsedRuntimes))
		runtime.SetFinalizer(vm, finalizer)
	}

	return jsvm, err
}
Exemplo n.º 30
0
func NewOttoCartesianProductJoiner() *OttoCartesianProductJoiner {
	return &OttoCartesianProductJoiner{
		OutputChannel: make(DocumentChannel),
		leftDocs:      make([]Document, 0),
		rightDocs:     make([]Document, 0),
		Otto:          otto.New()}
}