375 lines
9.8 KiB
Go
375 lines
9.8 KiB
Go
package core
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// the tag used to denote the name of the question
|
|
const tagName = "survey"
|
|
|
|
// Settable allow for configuration when assigning answers
|
|
type Settable interface {
|
|
WriteAnswer(field string, value interface{}) error
|
|
}
|
|
|
|
// OptionAnswer is the return type of Selects/MultiSelects that lets the appropriate information
|
|
// get copied to the user's struct
|
|
type OptionAnswer struct {
|
|
Value string
|
|
Index int
|
|
}
|
|
|
|
type reflectField struct {
|
|
value reflect.Value
|
|
fieldType reflect.StructField
|
|
}
|
|
|
|
func OptionAnswerList(incoming []string) []OptionAnswer {
|
|
list := []OptionAnswer{}
|
|
for i, opt := range incoming {
|
|
list = append(list, OptionAnswer{Value: opt, Index: i})
|
|
}
|
|
return list
|
|
}
|
|
|
|
func WriteAnswer(t interface{}, name string, v interface{}) (err error) {
|
|
// if the field is a custom type
|
|
if s, ok := t.(Settable); ok {
|
|
// use the interface method
|
|
return s.WriteAnswer(name, v)
|
|
}
|
|
|
|
// the target to write to
|
|
target := reflect.ValueOf(t)
|
|
// the value to write from
|
|
value := reflect.ValueOf(v)
|
|
|
|
// make sure we are writing to a pointer
|
|
if target.Kind() != reflect.Ptr {
|
|
return errors.New("you must pass a pointer as the target of a Write operation")
|
|
}
|
|
// the object "inside" of the target pointer
|
|
elem := target.Elem()
|
|
|
|
// handle the special types
|
|
switch elem.Kind() {
|
|
// if we are writing to a struct
|
|
case reflect.Struct:
|
|
// if we are writing to an option answer than we want to treat
|
|
// it like a single thing and not a place to deposit answers
|
|
if elem.Type().Name() == "OptionAnswer" {
|
|
// copy the value over to the normal struct
|
|
return copy(elem, value)
|
|
}
|
|
|
|
// get the name of the field that matches the string we were given
|
|
field, _, err := findField(elem, name)
|
|
// if something went wrong
|
|
if err != nil {
|
|
// bubble up
|
|
return err
|
|
}
|
|
// handle references to the Settable interface aswell
|
|
if s, ok := field.Interface().(Settable); ok {
|
|
// use the interface method
|
|
return s.WriteAnswer(name, v)
|
|
}
|
|
if field.CanAddr() {
|
|
if s, ok := field.Addr().Interface().(Settable); ok {
|
|
// use the interface method
|
|
return s.WriteAnswer(name, v)
|
|
}
|
|
}
|
|
|
|
// copy the value over to the normal struct
|
|
return copy(field, value)
|
|
case reflect.Map:
|
|
mapType := reflect.TypeOf(t).Elem()
|
|
if mapType.Key().Kind() != reflect.String {
|
|
return errors.New("answer maps key must be of type string")
|
|
}
|
|
|
|
// copy only string value/index value to map if,
|
|
// map is not of type interface and is 'OptionAnswer'
|
|
if value.Type().Name() == "OptionAnswer" {
|
|
if kval := mapType.Elem().Kind(); kval == reflect.String {
|
|
mt := *t.(*map[string]string)
|
|
mt[name] = value.FieldByName("Value").String()
|
|
return nil
|
|
} else if kval == reflect.Int {
|
|
mt := *t.(*map[string]int)
|
|
mt[name] = int(value.FieldByName("Index").Int())
|
|
return nil
|
|
}
|
|
}
|
|
|
|
if mapType.Elem().Kind() != reflect.Interface {
|
|
return errors.New("answer maps must be of type map[string]interface")
|
|
}
|
|
mt := *t.(*map[string]interface{})
|
|
mt[name] = value.Interface()
|
|
return nil
|
|
}
|
|
// otherwise just copy the value to the target
|
|
return copy(elem, value)
|
|
}
|
|
|
|
type errFieldNotMatch struct {
|
|
questionName string
|
|
}
|
|
|
|
func (err errFieldNotMatch) Error() string {
|
|
return fmt.Sprintf("could not find field matching %v", err.questionName)
|
|
}
|
|
|
|
func (err errFieldNotMatch) Is(target error) bool { // implements the dynamic errors.Is interface.
|
|
if target != nil {
|
|
if name, ok := IsFieldNotMatch(target); ok {
|
|
// if have a filled questionName then perform "deeper" comparison.
|
|
return name == "" || err.questionName == "" || name == err.questionName
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// IsFieldNotMatch reports whether an "err" is caused by a non matching field.
|
|
// It returns the Question.Name that couldn't be matched with a destination field.
|
|
//
|
|
// Usage:
|
|
// err := survey.Ask(qs, &v);
|
|
// if err != nil {
|
|
// if name, ok := core.IsFieldNotMatch(err); ok {
|
|
// [...name is the not matched question name]
|
|
// }
|
|
// }
|
|
func IsFieldNotMatch(err error) (string, bool) {
|
|
if err != nil {
|
|
if v, ok := err.(errFieldNotMatch); ok {
|
|
return v.questionName, true
|
|
}
|
|
}
|
|
|
|
return "", false
|
|
}
|
|
|
|
// BUG(AlecAivazis): the current implementation might cause weird conflicts if there are
|
|
// two fields with same name that only differ by casing.
|
|
func findField(s reflect.Value, name string) (reflect.Value, reflect.StructField, error) {
|
|
|
|
fields := flattenFields(s)
|
|
|
|
// first look for matching tags so we can overwrite matching field names
|
|
for _, f := range fields {
|
|
// the value of the survey tag
|
|
tag := f.fieldType.Tag.Get(tagName)
|
|
// if the tag matches the name we are looking for
|
|
if tag != "" && tag == name {
|
|
// then we found our index
|
|
return f.value, f.fieldType, nil
|
|
}
|
|
}
|
|
|
|
// then look for matching names
|
|
for _, f := range fields {
|
|
// if the name of the field matches what we're looking for
|
|
if strings.ToLower(f.fieldType.Name) == strings.ToLower(name) {
|
|
return f.value, f.fieldType, nil
|
|
}
|
|
}
|
|
|
|
// we didn't find the field
|
|
return reflect.Value{}, reflect.StructField{}, errFieldNotMatch{name}
|
|
}
|
|
|
|
func flattenFields(s reflect.Value) []reflectField {
|
|
sType := s.Type()
|
|
numField := sType.NumField()
|
|
fields := make([]reflectField, 0, numField)
|
|
for i := 0; i < numField; i++ {
|
|
fieldType := sType.Field(i)
|
|
field := s.Field(i)
|
|
|
|
if field.Kind() == reflect.Struct && fieldType.Anonymous {
|
|
// field is a promoted structure
|
|
for _, f := range flattenFields(field) {
|
|
fields = append(fields, f)
|
|
}
|
|
continue
|
|
}
|
|
fields = append(fields, reflectField{field, fieldType})
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// isList returns true if the element is something we can Len()
|
|
func isList(v reflect.Value) bool {
|
|
switch v.Type().Kind() {
|
|
case reflect.Array, reflect.Slice:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Write takes a value and copies it to the target
|
|
func copy(t reflect.Value, v reflect.Value) (err error) {
|
|
// if something ends up panicing we need to catch it in a deferred func
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
// if we paniced with an error
|
|
if _, ok := r.(error); ok {
|
|
// cast the result to an error object
|
|
err = r.(error)
|
|
} else if _, ok := r.(string); ok {
|
|
// otherwise we could have paniced with a string so wrap it in an error
|
|
err = errors.New(r.(string))
|
|
}
|
|
}
|
|
}()
|
|
|
|
// if we are copying from a string result to something else
|
|
if v.Kind() == reflect.String && v.Type() != t.Type() {
|
|
var castVal interface{}
|
|
var casterr error
|
|
vString := v.Interface().(string)
|
|
|
|
switch t.Kind() {
|
|
case reflect.Bool:
|
|
castVal, casterr = strconv.ParseBool(vString)
|
|
case reflect.Int:
|
|
castVal, casterr = strconv.Atoi(vString)
|
|
case reflect.Int8:
|
|
var val64 int64
|
|
val64, casterr = strconv.ParseInt(vString, 10, 8)
|
|
if casterr == nil {
|
|
castVal = int8(val64)
|
|
}
|
|
case reflect.Int16:
|
|
var val64 int64
|
|
val64, casterr = strconv.ParseInt(vString, 10, 16)
|
|
if casterr == nil {
|
|
castVal = int16(val64)
|
|
}
|
|
case reflect.Int32:
|
|
var val64 int64
|
|
val64, casterr = strconv.ParseInt(vString, 10, 32)
|
|
if casterr == nil {
|
|
castVal = int32(val64)
|
|
}
|
|
case reflect.Int64:
|
|
if t.Type() == reflect.TypeOf(time.Duration(0)) {
|
|
castVal, casterr = time.ParseDuration(vString)
|
|
} else {
|
|
castVal, casterr = strconv.ParseInt(vString, 10, 64)
|
|
}
|
|
case reflect.Uint:
|
|
var val64 uint64
|
|
val64, casterr = strconv.ParseUint(vString, 10, 8)
|
|
if casterr == nil {
|
|
castVal = uint(val64)
|
|
}
|
|
case reflect.Uint8:
|
|
var val64 uint64
|
|
val64, casterr = strconv.ParseUint(vString, 10, 8)
|
|
if casterr == nil {
|
|
castVal = uint8(val64)
|
|
}
|
|
case reflect.Uint16:
|
|
var val64 uint64
|
|
val64, casterr = strconv.ParseUint(vString, 10, 16)
|
|
if casterr == nil {
|
|
castVal = uint16(val64)
|
|
}
|
|
case reflect.Uint32:
|
|
var val64 uint64
|
|
val64, casterr = strconv.ParseUint(vString, 10, 32)
|
|
if casterr == nil {
|
|
castVal = uint32(val64)
|
|
}
|
|
case reflect.Uint64:
|
|
castVal, casterr = strconv.ParseUint(vString, 10, 64)
|
|
case reflect.Float32:
|
|
var val64 float64
|
|
val64, casterr = strconv.ParseFloat(vString, 32)
|
|
if casterr == nil {
|
|
castVal = float32(val64)
|
|
}
|
|
case reflect.Float64:
|
|
castVal, casterr = strconv.ParseFloat(vString, 64)
|
|
default:
|
|
return fmt.Errorf("Unable to convert from string to type %s", t.Kind())
|
|
}
|
|
|
|
if casterr != nil {
|
|
return casterr
|
|
}
|
|
|
|
t.Set(reflect.ValueOf(castVal))
|
|
return
|
|
}
|
|
|
|
// if we are copying from an OptionAnswer to something
|
|
if v.Type().Name() == "OptionAnswer" {
|
|
// copying an option answer to a string
|
|
if t.Kind() == reflect.String {
|
|
// copies the Value field of the struct
|
|
t.Set(reflect.ValueOf(v.FieldByName("Value").Interface()))
|
|
return
|
|
}
|
|
|
|
// copying an option answer to an int
|
|
if t.Kind() == reflect.Int {
|
|
// copies the Index field of the struct
|
|
t.Set(reflect.ValueOf(v.FieldByName("Index").Interface()))
|
|
return
|
|
}
|
|
|
|
// copying an OptionAnswer to an OptionAnswer
|
|
if t.Type().Name() == "OptionAnswer" {
|
|
t.Set(v)
|
|
return
|
|
}
|
|
|
|
// we're copying an option answer to an incorrect type
|
|
return fmt.Errorf("Unable to convert from OptionAnswer to type %s", t.Kind())
|
|
}
|
|
|
|
// if we are copying from one slice or array to another
|
|
if isList(v) && isList(t) {
|
|
// loop over every item in the desired value
|
|
for i := 0; i < v.Len(); i++ {
|
|
// write to the target given its kind
|
|
switch t.Kind() {
|
|
// if its a slice
|
|
case reflect.Slice:
|
|
// an object of the correct type
|
|
obj := reflect.Indirect(reflect.New(t.Type().Elem()))
|
|
|
|
// write the appropriate value to the obj and catch any errors
|
|
if err := copy(obj, v.Index(i)); err != nil {
|
|
return err
|
|
}
|
|
|
|
// just append the value to the end
|
|
t.Set(reflect.Append(t, obj))
|
|
// otherwise it could be an array
|
|
case reflect.Array:
|
|
// set the index to the appropriate value
|
|
copy(t.Slice(i, i+1).Index(0), v.Index(i))
|
|
}
|
|
}
|
|
} else {
|
|
// set the value to the target
|
|
t.Set(v)
|
|
}
|
|
|
|
// we're done
|
|
return
|
|
}
|