Esempio n. 1
0
func toValue(vm *motto.Motto, value interface{}) otto.Value {
	var err error
	var val otto.Value
	switch n := value.(type) {
	case dict.Map, map[string]interface{}:
		bs, e := json.Marshal(n)
		if e != nil {
			err = e
			return otto.UndefinedValue()
		}
		object, oe := vm.Object("(" + string(bs) + ")")
		if oe != nil {
			err = oe
		} else {
			val = object.Value()
		}

	default:
		val, err = vm.ToValue(n)
	}

	if err != nil {
		log.Printf("Could not convert %v", err)
		return otto.UndefinedValue()
	}

	return val
}
Esempio n. 2
0
func fsModule(vm *motto.Motto) (otto.Value, error) {
	fs, err := vm.Object(`({})`)

	if err != nil {
		return otto.UndefinedValue(), err
	}

	fs.Set("readFile", func(call otto.FunctionCall) otto.Value {
		if !call.Argument(1).IsFunction() {
			panic(errors.New("function"))
			return otto.UndefinedValue()
		}

		vm.RunLoop.Async(call.Argument(1), func(done func(args ...interface{})) {

			go func() {
				filename, _ := call.Argument(0).ToString()
				bytes, err := ioutil.ReadFile(filename)
				if err != nil {
					done(err)
				} else {
					v, e := call.Otto.ToValue(string(bytes))
					if e == nil {
						done(otto.NullValue(), v)
					} else {
						done(e)
					}

				}

			}()

		})

		return otto.UndefinedValue()
	})

	return vm.ToValue(fs)
}