vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go

   1 package mapstructure
   2
   3 import (
   4         "fmt"
   5 )
   6
   7 func ExampleDecode() {
   8         type Person struct {
   9                 Name   string
  10                 Age    int
  11                 Emails []string
  12                 Extra  map[string]string
  13         }
  14
  15         // This input can come from anywhere, but typically comes from
  16         // something like decoding JSON where we're not quite sure of the
  17         // struct initially.
  18         input := map[string]interface{}{
  19                 "name":   "Mitchell",
  20                 "age":    91,
  21                 "emails": []string{"one", "two", "three"},
  22                 "extra": map[string]string{
  23                         "twitter": "mitchellh",
  24                 },
  25         }
  26
  27         var result Person
  28         err := Decode(input, &result)
  29         if err != nil {
  30                 panic(err)
  31         }
  32
  33         fmt.Printf("%#v", result)
  34         // Output:
  35         // mapstructure.Person{Name:"Mitchell", Age:91, Emails:[]string{"one", "two", "three"}, Extra:map[string]string{"twitter":"mitchellh"}}
  36 }
  37
  38 func ExampleDecode_errors() {
  39         type Person struct {
  40                 Name   string
  41                 Age    int
  42                 Emails []string
  43                 Extra  map[string]string
  44         }
  45
  46         // This input can come from anywhere, but typically comes from
  47         // something like decoding JSON where we're not quite sure of the
  48         // struct initially.
  49         input := map[string]interface{}{
  50                 "name":   123,
  51                 "age":    "bad value",
  52                 "emails": []int{1, 2, 3},
  53         }
  54
  55         var result Person
  56         err := Decode(input, &result)
  57         if err == nil {
  58                 panic("should have an error")
  59         }
  60
  61         fmt.Println(err.Error())
  62         // Output:
  63         // 5 error(s) decoding:
  64         //
  65         // * 'Age' expected type 'int', got unconvertible type 'string'
  66         // * 'Emails[0]' expected type 'string', got unconvertible type 'int'
  67         // * 'Emails[1]' expected type 'string', got unconvertible type 'int'
  68         // * 'Emails[2]' expected type 'string', got unconvertible type 'int'
  69         // * 'Name' expected type 'string', got unconvertible type 'int'
  70 }
  71
  72 func ExampleDecode_metadata() {
  73         type Person struct {
  74                 Name string
  75                 Age  int
  76         }
  77
  78         // This input can come from anywhere, but typically comes from
  79         // something like decoding JSON where we're not quite sure of the
  80         // struct initially.
  81         input := map[string]interface{}{
  82                 "name":  "Mitchell",
  83                 "age":   91,
  84                 "email": "foo@bar.com",
  85         }
  86
  87         // For metadata, we make a more advanced DecoderConfig so we can
  88         // more finely configure the decoder that is used. In this case, we
  89         // just tell the decoder we want to track metadata.
  90         var md Metadata
  91         var result Person
  92         config := &DecoderConfig{
  93                 Metadata: &md,
  94                 Result:   &result,
  95         }
  96
  97         decoder, err := NewDecoder(config)
  98         if err != nil {
  99                 panic(err)
 100         }
 101
 102         if err := decoder.Decode(input); err != nil {
 103                 panic(err)
 104         }
 105
 106         fmt.Printf("Unused keys: %#v", md.Unused)
 107         // Output:
 108         // Unused keys: []string{"email"}
 109 }
 110
 111 func ExampleDecode_weaklyTypedInput() {
 112         type Person struct {
 113                 Name   string
 114                 Age    int
 115                 Emails []string
 116         }
 117
 118         // This input can come from anywhere, but typically comes from
 119         // something like decoding JSON, generated by a weakly typed language
 120         // such as PHP.
 121         input := map[string]interface{}{
 122                 "name":   123,                      // number => string
 123                 "age":    "42",                     // string => number
 124                 "emails": map[string]interface{}{}, // empty map => empty array
 125         }
 126
 127         var result Person
 128         config := &DecoderConfig{
 129                 WeaklyTypedInput: true,
 130                 Result:           &result,
 131         }
 132
 133         decoder, err := NewDecoder(config)
 134         if err != nil {
 135                 panic(err)
 136         }
 137
 138         err = decoder.Decode(input)
 139         if err != nil {
 140                 panic(err)
 141         }
 142
 143         fmt.Printf("%#v", result)
 144         // Output: mapstructure.Person{Name:"123", Age:42, Emails:[]string{}}
 145 }
 146
 147 func ExampleDecode_tags() {
 148         // Note that the mapstructure tags defined in the struct type
 149         // can indicate which fields the values are mapped to.
 150         type Person struct {
 151                 Name string `mapstructure:"person_name"`
 152                 Age  int    `mapstructure:"person_age"`
 153         }
 154
 155         input := map[string]interface{}{
 156                 "person_name": "Mitchell",
 157                 "person_age":  91,
 158         }
 159
 160         var result Person
 161         err := Decode(input, &result)
 162         if err != nil {
 163                 panic(err)
 164         }
 165
 166         fmt.Printf("%#v", result)
 167         // Output:
 168         // mapstructure.Person{Name:"Mitchell", Age:91}
 169 }
 170
 171 func ExampleDecode_embeddedStruct() {
 172         // Squashing multiple embedded structs is allowed using the squash tag.
 173         // This is demonstrated by creating a composite struct of multiple types
 174         // and decoding into it. In this case, a person can carry with it both
 175         // a Family and a Location, as well as their own FirstName.
 176         type Family struct {
 177                 LastName string
 178         }
 179         type Location struct {
 180                 City string
 181         }
 182         type Person struct {
 183                 Family    `mapstructure:",squash"`
 184                 Location  `mapstructure:",squash"`
 185                 FirstName string
 186         }
 187
 188         input := map[string]interface{}{
 189                 "FirstName": "Mitchell",
 190                 "LastName":  "Hashimoto",
 191                 "City":      "San Francisco",
 192         }
 193
 194         var result Person
 195         err := Decode(input, &result)
 196         if err != nil {
 197                 panic(err)
 198         }
 199
 200         fmt.Printf("%s %s, %s", result.FirstName, result.LastName, result.City)
 201         // Output:
 202         // Mitchell Hashimoto, San Francisco
 203 }