+
+
package qstring
+
+import (
+ "net/url"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// Unmarshaller defines the interface for performing custom unmarshalling of
+// query strings into struct values
+type Unmarshaller interface {
+ UnmarshalQuery(url.Values) error
+}
+
+// Unmarshal unmarshalls the provided url.Values (query string) into the
+// interface provided
+func Unmarshal(data url.Values, v interface{}) error {
+ var d decoder
+ d.init(data)
+ return d.unmarshal(v)
+}
+
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+// (The argument to Unmarshal must be a non-nil pointer.)
+type InvalidUnmarshalError struct {
+ Type reflect.Type
+}
+
+func (e InvalidUnmarshalError) Error() string {
+ if e.Type == nil {
+ return "qstring: Unmarshal(nil)"
+ }
+
+ if e.Type.Kind() != reflect.Ptr {
+ return "qstring: Unmarshal(non-pointer " + e.Type.String() + ")"
+ }
+ return "qstring: Unmarshal(nil " + e.Type.String() + ")"
+}
+
+type decoder struct {
+ data url.Values
+}
+
+func (d *decoder) init(data url.Values) *decoder {
+ d.data = data
+ return d
+}
+
+func (d *decoder) unmarshal(v interface{}) error {
+ rv := reflect.ValueOf(v)
+ if rv.Kind() != reflect.Ptr || rv.IsNil() {
+ return &InvalidUnmarshalError{reflect.TypeOf(v)}
+ }
+
+ return d.value(rv)
+}
+
+func (d *decoder) value(val reflect.Value) error {
+ elem := val.Elem()
+ typ := elem.Type()
+ for i := 0; i < elem.NumField(); i++ {
+ // pull out the qstring struct tag
+ elemField := elem.Field(i)
+ typField := typ.Field(i)
+ qstring := typField.Tag.Get(Tag)
+ if qstring == "" {
+ // resolvable fields must have at least the `flag` struct tag
+ qstring = strings.ToLower(typField.Name)
+ }
+
+ // determine if this is an unsettable field or was explicitly set to be
+ // ignored
+ if !elemField.CanSet() || qstring == "-" {
+ continue
+ }
+
+ // only do work if the current fields query string parameter was provided
+ if query, ok := d.data[qstring]; ok {
+ switch k := typField.Type.Kind(); k {
+ case reflect.Slice:
+ d.coerceSlice(query, k, elemField)
+ default:
+ d.coerce(query[0], k, elemField)
+ }
+ } else if typField.Type.Kind() == reflect.Struct {
+ if elemField.CanAddr() {
+ d.value(elemField.Addr())
+ }
+ }
+ }
+ return nil
+}
+
+// coerce converts the provided query parameter slice into the proper type for
+// the target field. this coerced value is then assigned to the current field
+func (d *decoder) coerce(query string, target reflect.Kind, field reflect.Value) error {
+ var err error
+ var c interface{}
+
+ switch target {
+ case reflect.String:
+ field.SetString(query)
+ case reflect.Bool:
+ c, err = strconv.ParseBool(query)
+ if err == nil {
+ field.SetBool(c.(bool))
+ }
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ c, err = strconv.ParseInt(query, 10, 64)
+ if err == nil {
+ field.SetInt(c.(int64))
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ c, err = strconv.ParseUint(query, 10, 64)
+ if err == nil {
+ field.SetUint(c.(uint64))
+ }
+ case reflect.Float32, reflect.Float64:
+ c, err = strconv.ParseFloat(query, 64)
+ if err == nil {
+ field.SetFloat(c.(float64))
+ }
+ case reflect.Struct:
+ switch field.Interface().(type) {
+ case time.Time:
+ var t time.Time
+ t, err = time.Parse(time.RFC3339, query)
+ if err == nil {
+ field.Set(reflect.ValueOf(t))
+ }
+ default:
+ d.value(field)
+ }
+ }
+
+ return err
+}
+
+// coerceSlice creates a new slice of the appropriate type for the target field
+// and coerces each of the query parameter values into the destination type.
+// Should any of the provided query parameters fail to be coerced, an error is
+// returned and the entire slice will not be applied
+func (d *decoder) coerceSlice(query []string, target reflect.Kind, field reflect.Value) error {
+ var err error
+ sliceType := field.Type().Elem()
+ coerceKind := sliceType.Kind()
+ sl := reflect.MakeSlice(reflect.SliceOf(sliceType), 0, 0)
+ // Create a pointer to a slice value and set it to the slice
+ slice := reflect.New(sl.Type())
+ slice.Elem().Set(sl)
+ for _, q := range query {
+ val := reflect.New(sliceType).Elem()
+ err = d.coerce(q, coerceKind, val)
+ if err != nil {
+ return err
+ }
+ slice.Elem().Set(reflect.Append(slice.Elem(), val))
+ }
+ field.Set(slice.Elem())
+ return nil
+}
+
+
+
package qstring
+
+import (
+ "net/url"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// Marshaller defines the interface for performing custom marshalling of struct
+// values into query strings
+type Marshaller interface {
+ MarshalQuery() (url.Values, error)
+}
+
+// MarshalValues marshals the provided struct into a url.Values collection
+func MarshalValues(v interface{}) (url.Values, error) {
+ var e encoder
+ e.init(v)
+ return e.marshal()
+}
+
+// Marshal marshals the provided struct into a raw query string and returns a
+// conditional error
+func Marshal(v interface{}) (string, error) {
+ vals, err := MarshalValues(v)
+ if err != nil {
+ return "", err
+ }
+ return vals.Encode(), nil
+}
+
+// An InvalidMarshalError describes an invalid argument passed to Marshal or
+// MarshalValue. (The argument to Marshal must be a non-nil pointer.)
+type InvalidMarshalError struct {
+ Type reflect.Type
+}
+
+func (e InvalidMarshalError) Error() string {
+ if e.Type == nil {
+ return "qstring: Marshal(nil)"
+ }
+
+ if e.Type.Kind() != reflect.Ptr {
+ return "qstring: Marshal(non-pointer " + e.Type.String() + ")"
+ }
+ return "qstring: Marshal(nil " + e.Type.String() + ")"
+}
+
+type encoder struct {
+ data interface{}
+}
+
+func (e *encoder) init(v interface{}) *encoder {
+ e.data = v
+ return e
+}
+
+func (e *encoder) marshal() (url.Values, error) {
+ rv := reflect.ValueOf(e.data)
+ if rv.Kind() != reflect.Ptr || rv.IsNil() {
+ return nil, &InvalidMarshalError{reflect.TypeOf(e.data)}
+ }
+
+ return e.value(rv)
+}
+
+func (e *encoder) value(val reflect.Value) (url.Values, error) {
+ elem := val.Elem()
+ typ := elem.Type()
+
+ var err error
+ var output = make(url.Values)
+ for i := 0; i < elem.NumField(); i++ {
+ // pull out the qstring struct tag
+ elemField := elem.Field(i)
+ typField := typ.Field(i)
+ qstring := typField.Tag.Get(Tag)
+ if qstring == "" {
+ // resolvable fields must have at least the `flag` struct tag
+ qstring = strings.ToLower(typField.Name)
+ }
+
+ // determine if this is an unsettable field or was explicitly set to be
+ // ignored
+ if !elemField.CanSet() || qstring == "-" || isEmptyValue(elemField) {
+ continue
+ }
+
+ // only do work if the current fields query string parameter was provided
+ switch k := typField.Type.Kind(); k {
+ case reflect.Slice:
+ output[qstring] = marshalSlice(elemField)
+ case reflect.Struct:
+ switch elemField.Interface().(type) {
+ case time.Time:
+ output.Set(qstring, marshalValue(elemField, k))
+ default:
+ var vals url.Values
+ if elemField.CanAddr() {
+ vals, err = MarshalValues(elemField.Addr().Interface())
+ }
+
+ if err != nil {
+ return output, err
+ }
+ for key, list := range vals {
+ output[key] = list
+ }
+ }
+ default:
+ output.Set(qstring, marshalValue(elemField, k))
+ }
+ }
+ return output, err
+}
+
+func marshalSlice(field reflect.Value) []string {
+ var out []string
+ for i := 0; i < field.Len(); i++ {
+ out = append(out, marshalValue(field.Index(i), field.Index(i).Kind()))
+ }
+ return out
+}
+
+func marshalValue(field reflect.Value, source reflect.Kind) string {
+ switch source {
+ case reflect.String:
+ return field.String()
+ case reflect.Bool:
+ return strconv.FormatBool(field.Bool())
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return strconv.FormatInt(field.Int(), 10)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ return strconv.FormatUint(field.Uint(), 10)
+ case reflect.Float32, reflect.Float64:
+ return strconv.FormatFloat(field.Float(), 'G', -1, 64)
+ case reflect.Struct:
+ switch field.Interface().(type) {
+ case time.Time:
+ return field.Interface().(time.Time).Format(time.RFC3339)
+ }
+ }
+ return ""
+}
+
+
+
package qstring
+
+import (
+ "reflect"
+)
+
+// isEmptyValue returns true if the provided reflect.Value
+func isEmptyValue(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Interface, reflect.Ptr:
+ return v.IsNil()
+ }
+ return false
+}
+
+
+