string_slice.go

package meta

import (
	"reflect"
	"strings"
	"unicode/utf8"
)

type StringSlice struct {
	Presence
	Nullity
	Val  []string
	Path string
}

type StringSliceOptions struct {
	*StringOptions
	*SliceOptions
}

func (i *StringSlice) ParseOptions(tag reflect.StructTag) interface{} {
	var tempS String
	opts := tempS.ParseOptions(tag)

	// unlike String we want Blank to default to true so we can clean up input values like: a,b,c,,,d
	stringOpts := opts.(*StringOptions)
	stringOpts.Blank = true
	if tag.Get("meta_blank") == "false" {
		stringOpts.Blank = false
	}

	return &StringSliceOptions{
		StringOptions: stringOpts,
		SliceOptions:  ParseSliceOptions(tag),
	}
}

func (n *StringSlice) JSONValue(path string, i interface{}, options interface{}) Errorable {
	opts := options.(*StringSliceOptions)
	stringOpts := opts.StringOptions
	sliceOpts := opts.SliceOptions

	n.Path = path
	n.Val = nil
	n.Present = true
	n.Null = false

	if i == nil {
		n.Null = true
		if sliceOpts.DiscardBlank {
			n.Present = false
			return nil
		} else if sliceOpts.Null {
			return nil
		}
		return ErrBlank
	}

	var errorsInSlice ErrorSlice
	switch value := i.(type) {
	case string:
		return n.FormValue(value, options)
	case []interface{}:
		n.Val = []string{}

		if sliceOpts.MinLengthPresent && len(value) < sliceOpts.MinLength {
			return ErrMinLength
		}

		if sliceOpts.MaxLengthPresent && len(value) > sliceOpts.MaxLength {
			return ErrMaxLength
		}

		if len(value) == 0 {
			if sliceOpts.DiscardBlank {
				n.Present = false
				return nil
			} else if sliceOpts.Blank {
				return nil
			}
			return ErrBlank
		}

		for _, v := range value {
			var s String
			if err := s.JSONValue("", v, stringOpts); err != nil {
				errorsInSlice = append(errorsInSlice, err)
				if err == ErrBlank && !stringOpts.DiscardBlank {
					n.Val = append(n.Val, s.Val)
				}
			} else {
				if !stringOpts.DiscardBlank || s.Val != "" {
					errorsInSlice = append(errorsInSlice, nil)
					n.Val = append(n.Val, s.Val)
				}
			}
		}
		if errorsInSlice.Len() > 0 {
			return errorsInSlice
		}

		if sliceOpts.MinLengthPresent && len(n.Val) < sliceOpts.MinLength {
			return ErrMinLength
		}

		if sliceOpts.MaxLengthPresent && len(n.Val) > sliceOpts.MaxLength {
			return ErrMaxLength
		}

		if len(n.Val) == 0 {
			if sliceOpts.DiscardBlank {
				n.Present = false
				return nil
			} else if sliceOpts.Blank {
				return nil
			}
			return ErrBlank
		}
	}
	return nil

}

func (i *StringSlice) FormValue(value string, options interface{}) Errorable {
	if !utf8.ValidString(value) {
		return ErrUtf8
	}

	i.Val = []string{}
	i.Present = true
	i.Null = false

	opts := options.(*StringSliceOptions)
	stringOpts := opts.StringOptions
	sliceOpts := opts.SliceOptions

	if sliceOpts.Strip {
		value = strings.TrimSpace(value)
	}

	if value == "" {
		if sliceOpts.DiscardBlank {
			i.Present = false
			return nil
		} else if sliceOpts.Blank {
			return nil
		}
		return ErrBlank
	}

	var tempS String
	strs := strings.Split(value, ",")

	if sliceOpts.MinLengthPresent && len(strs) < sliceOpts.MinLength {
		return ErrMinLength
	}

	if sliceOpts.MaxLengthPresent && len(strs) > sliceOpts.MaxLength {
		return ErrMaxLength
	}

	var errorsInSlice ErrorSlice

	for _, s := range strs {
		tempS.Val = ""

		if err := tempS.FormValue(s, stringOpts); err != nil {
			errorsInSlice = append(errorsInSlice, err)
			if err == ErrBlank && !stringOpts.DiscardBlank {
				i.Val = append(i.Val, tempS.Val)
			}
		} else {
			if !stringOpts.DiscardBlank || tempS.Val != "" {
				errorsInSlice = append(errorsInSlice, nil)
				i.Val = append(i.Val, tempS.Val)
			}
		}
	}

	if errorsInSlice.Len() > 0 {
		return errorsInSlice
	}

	if sliceOpts.MinLengthPresent && len(i.Val) < sliceOpts.MinLength {
		return ErrMinLength
	}

	if sliceOpts.MaxLengthPresent && len(i.Val) > sliceOpts.MaxLength {
		return ErrMaxLength
	}

	if len(i.Val) == 0 {
		if sliceOpts.DiscardBlank {
			i.Present = false
			return nil
		} else if sliceOpts.Blank {
			return nil
		}
		return ErrBlank
	}

	return nil
}

func (s StringSlice) MarshalJSON() ([]byte, error) {
	if len(s.Val) > 0 {
		return MetaJson.Marshal(s.Val)
	}
	return nullString, nil
}

func (s *StringSlice) UnmarshalJSON(data []byte) error {
	var value []string
	err := MetaJson.Unmarshal(data, &value)
	if err != nil {
		return err
	}
	*s = StringSlice{Val: value}
	return nil
}