func formatOneLine(v otto.Value, limit int, seen map[otto.Value]bool) (string, error) {
if limit == 0 {
return "...", nil
}
switch {
case v.IsBoolean(), v.IsNull(), v.IsNumber(), v.IsUndefined():
return v.String(), nil
case v.IsString():
return fmt.Sprintf("%q", v.String()), nil
case v.IsFunction():
n, err := v.Object().Get("name")
if err != nil {
return "", err
}
if n.IsUndefined() {
return "function", nil
}
return fmt.Sprintf("function %s", n.String()), nil
case v.IsObject():
switch v.Class() {
case "Array":
return formatArrayOneLine(v, limit, seen)
default:
return formatObjectOneLine(v, limit, seen)
}
default:
return "", fmt.Errorf("couldn't format type %s", v.Class())
}
}
// Execute Javascript
func (sh *Shell) execScript(editor bool) stateFn {
var out string
var value otto.Value
var err error
if !editor {
tmp := strings.TrimPrefix(sh.input, RunJavascript) // remove script meta-command
value, err = sh.jsengine.Run(tmp)
} else {
value, err = sh.jsengine.Run(sh.input)
}
if err != nil {
out = err.Error()
} else if value.IsDefined() {
out = value.String()
}
sh.write(out)
if !editor {
sh.line.AppendHistory(sh.input)
}
return bqlPrompt
}
func inspect(v otto.Value, width, indent int) string {
switch {
case v.IsBoolean(), v.IsNull(), v.IsNumber(), v.IsString(), v.IsUndefined(), v.IsNaN():
return fmt.Sprintf("%s%q", strings.Repeat(" ", indent), v.String())
default:
return ""
}
}
func buildIteratorFromValue(val otto.Value, ts graph.TripleStore) graph.Iterator {
if val.IsNull() || val.IsUndefined() {
return ts.NodesAllIterator()
}
if val.IsPrimitive() {
thing, _ := val.Export()
switch v := thing.(type) {
case string:
it := ts.FixedIterator()
it.Add(ts.ValueOf(v))
return it
default:
glog.Errorln("Trying to build unknown primitive value.")
}
}
switch val.Class() {
case "Object":
return buildIteratorTree(val.Object(), ts)
case "Array":
// Had better be an array of strings
strings := stringsFrom(val.Object())
it := ts.FixedIterator()
for _, x := range strings {
it.Add(ts.ValueOf(x))
}
return it
case "Number":
fallthrough
case "Boolean":
fallthrough
case "Date":
fallthrough
case "String":
it := ts.FixedIterator()
it.Add(ts.ValueOf(val.String()))
return it
default:
glog.Errorln("Trying to handle unsupported Javascript value.")
return iterator.NewNull()
}
}
func buildPathFromValue(val otto.Value) (out []interface{}) {
if val.IsNull() || val.IsUndefined() {
return nil
}
if val.IsPrimitive() {
thing, _ := val.Export()
switch v := thing.(type) {
case string:
out = append(out, v)
return
default:
clog.Errorf("Trying to build unknown primitive value.")
}
}
switch val.Class() {
case "Object":
out = append(out, buildPathFromObject(val.Object()))
return
case "Array":
// Had better be an array of strings
for _, x := range stringsFrom(val.Object()) {
out = append(out, x)
}
return
case "Number":
fallthrough
case "Boolean":
fallthrough
case "Date":
fallthrough
case "String":
out = append(out, val.String())
return
default:
clog.Errorf("Trying to handle unsupported Javascript value.")
return nil
}
}
func (s *Scripting) TriggerEvent(eventName string, rawArguments ...interface{}) (err error) {
var (
present bool
callbacks []otto.Value
callback otto.Value
response otto.Value
arguments []interface{}
)
if callbacks, present = s.listeners[eventName]; !present {
return // Not an error to have no listeners.
}
if arguments, err = s.convertArguments(rawArguments); err != nil {
return
}
for _, callback = range callbacks {
if response, err = callback.Call(callback, arguments...); err != nil {
return
}
if response.IsString() {
fmt.Printf("Response from callback: %s\n", response.String())
}
}
return
}
func formatIndent(v otto.Value, width, indent, limit, level, additional int, seen map[otto.Value]bool) (string, error) {
if limit == 0 {
return "...", nil
}
switch {
case v.IsBoolean(), v.IsNull(), v.IsNumber(), v.IsUndefined():
return v.String(), nil
case v.IsString():
return fmt.Sprintf("%q", v.String()), nil
case v.IsFunction():
n, err := v.Object().Get("name")
if err != nil {
return "", err
}
if n.IsUndefined() {
return "function", nil
}
return fmt.Sprintf("function %s", n.String()), nil
case v.IsObject():
if d, err := formatOneLine(v, limit, seen); err != nil {
return "", err
} else if level*indent+additional+len(d) <= width {
return d, nil
}
switch v.Class() {
case "Array":
return formatArray(v, width, indent, limit, level, seen)
default:
return formatObject(v, width, indent, limit, level, seen)
}
default:
return "", fmt.Errorf("couldn't format type %s", v.Class())
}
}