1
0
mirror of https://github.com/MontFerret/ferret.git synced 2024-12-16 11:37:36 +02:00
ferret/pkg/runtime/values/helpers.go

309 lines
5.7 KiB
Go
Raw Normal View History

2018-09-18 22:42:38 +02:00
package values
import (
2018-09-26 01:04:07 +02:00
"encoding/json"
2018-09-29 03:04:16 +02:00
"reflect"
2018-09-18 22:42:38 +02:00
"time"
"github.com/MontFerret/ferret/pkg/runtime/core"
2018-09-18 22:42:38 +02:00
)
func GetIn(from core.Value, byPath []core.Value) (core.Value, error) {
if byPath == nil || len(byPath) == 0 {
return None, nil
}
var result = from
var err error
for _, segment := range byPath {
if result == None || result == nil {
break
}
segmentType := segment.Type()
switch result.Type() {
case core.ObjectType:
obj := result.(*Object)
if segmentType != core.StringType {
return nil, core.TypeError(segmentType, core.StringType)
}
result, _ = obj.Get(segment.(String))
break
case core.ArrayType:
arr := result.(*Array)
if segmentType != core.IntType {
return nil, core.TypeError(segmentType, core.IntType)
}
result = arr.Get(segment.(Int))
break
2018-10-06 00:30:03 +02:00
case core.HTMLElementType, core.HTMLDocumentType:
el := result.(HTMLNode)
2018-09-18 22:42:38 +02:00
if segmentType == core.IntType {
result = el.GetChildNode(segment.(Int))
} else if segmentType == core.StringType {
strSegment := segment.(String)
switch strSegment {
case "nodeType":
result = el.NodeType()
case "nodeName":
result = el.NodeName()
case "innerText":
result = el.InnerText()
case "innerHTML":
2018-10-06 01:40:09 +02:00
result = el.InnerHTML()
2018-09-18 22:42:38 +02:00
case "value":
result = el.Value()
case "attributes":
result = el.GetAttributes()
case "children":
result = el.GetChildNodes()
case "length":
result = el.Length()
case "url":
2018-10-06 00:30:03 +02:00
if result.Type() == core.HTMLDocumentType {
doc, ok := result.(HTMLDocument)
if ok {
2018-10-06 01:40:09 +02:00
result = doc.URL()
}
}
2018-09-18 22:42:38 +02:00
default:
result = None
}
if err != nil {
return None, err
}
} else {
return nil, core.TypeError(segmentType, core.IntType, core.StringType)
}
default:
return None, core.TypeError(
from.Type(),
core.ArrayType,
core.ObjectType,
2018-10-06 00:30:03 +02:00
core.HTMLDocumentType,
core.HTMLElementType,
2018-09-18 22:42:38 +02:00
)
}
}
return result, nil
}
func SetIn(to core.Value, byPath []core.Value, value core.Value) error {
if byPath == nil || len(byPath) == 0 {
return nil
}
var parent core.Value
var current = to
target := len(byPath) - 1
for idx, segment := range byPath {
parent = current
isTarget := target == idx
segmentType := segment.Type()
switch parent.Type() {
case core.ObjectType:
parent := parent.(*Object)
if segmentType != core.StringType {
return core.TypeError(segmentType, core.StringType)
}
if isTarget == false {
current, _ = parent.Get(segment.(String))
} else {
parent.Set(segment.(String), value)
}
break
case core.ArrayType:
if segmentType != core.IntType {
return core.TypeError(segmentType, core.IntType)
}
parent := parent.(*Array)
if isTarget == false {
current = parent.Get(segment.(Int))
} else {
parent.Set(segment.(Int), value)
}
break
default:
// redefine parent
isArray := segmentType == core.IntType
// it's not an index
if isArray == false {
obj := NewObject()
parent = obj
if segmentType != core.StringType {
return core.TypeError(segmentType, core.StringType)
}
if isTarget {
obj.Set(segment.(String), value)
}
} else {
arr := NewArray(10)
parent = arr
if isTarget {
arr.Set(segment.(Int), value)
}
}
// set new parent
SetIn(to, byPath[0:idx-1], parent)
if isTarget == false {
current = None
}
}
}
return nil
}
func Parse(input interface{}) core.Value {
switch input.(type) {
case bool:
return NewBoolean(input.(bool))
case string:
return NewString(input.(string))
case int:
return NewInt(input.(int))
case float64:
return NewFloat(input.(float64))
case float32:
return NewFloat(float64(input.(float32)))
case time.Time:
return NewDateTime(input.(time.Time))
case []interface{}:
input := input.([]interface{})
arr := NewArray(len(input))
for _, el := range input {
arr.Push(Parse(el))
}
return arr
case map[string]interface{}:
input := input.(map[string]interface{})
obj := NewObject()
for key, el := range input {
obj.Set(NewString(key), Parse(el))
}
return obj
case []byte:
return NewBinary(input.([]byte))
2018-10-04 16:38:42 +02:00
case nil:
return None
2018-09-29 03:04:16 +02:00
default:
v := reflect.ValueOf(input)
t := reflect.TypeOf(input)
kind := t.Kind()
if kind == reflect.Slice || kind == reflect.Array {
size := v.Len()
arr := NewArray(size)
2018-10-05 23:01:54 +02:00
for i := 0; i < size; i++ {
2018-09-29 03:04:16 +02:00
value := v.Index(i)
arr.Push(Parse(value.Interface()))
}
return arr
}
if kind == reflect.Map {
keys := v.MapKeys()
obj := NewObject()
for _, k := range keys {
key := Parse(k.Interface())
value := v.MapIndex(k)
obj.Set(NewString(key.String()), Parse(value.Interface()))
}
return obj
}
if kind == reflect.Struct {
obj := NewObject()
size := t.NumField()
2018-10-05 23:01:54 +02:00
for i := 0; i < size; i++ {
2018-09-29 03:04:16 +02:00
field := t.Field(i)
value := v.Field(i)
2018-09-18 22:42:38 +02:00
2018-09-29 03:04:16 +02:00
obj.Set(NewString(field.Name), Parse(value.Interface()))
}
return obj
}
return None
}
2018-09-18 22:42:38 +02:00
}
2018-09-23 02:28:33 +02:00
2018-09-26 01:04:07 +02:00
func Unmarshal(value json.RawMessage) (core.Value, error) {
var o interface{}
err := json.Unmarshal(value, &o)
if err != nil {
return None, err
}
return Parse(o), nil
}
2018-09-23 02:28:33 +02:00
func ToBoolean(input core.Value) core.Value {
switch input.Type() {
case core.BooleanType:
return input
case core.NoneType:
return False
case core.StringType:
return NewBoolean(input.String() != "")
case core.IntType:
return NewBoolean(input.(Int) != 0)
case core.FloatType:
return NewBoolean(input.(Float) != 0)
default:
return True
}
}
func IsCloneable(value core.Value) Boolean {
switch value.Type() {
case core.ArrayType:
return NewBoolean(true)
case core.ObjectType:
return NewBoolean(true)
default:
return NewBoolean(false)
}
}