Matthias Andreas Benkard | 832a54e | 2019-01-29 09:27:38 +0100 | [diff] [blame^] | 1 | package yaml |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "encoding/json" |
| 6 | "fmt" |
| 7 | "reflect" |
| 8 | "strconv" |
| 9 | |
| 10 | "gopkg.in/yaml.v2" |
| 11 | ) |
| 12 | |
| 13 | // Marshals the object into JSON then converts JSON to YAML and returns the |
| 14 | // YAML. |
| 15 | func Marshal(o interface{}) ([]byte, error) { |
| 16 | j, err := json.Marshal(o) |
| 17 | if err != nil { |
| 18 | return nil, fmt.Errorf("error marshaling into JSON: %v", err) |
| 19 | } |
| 20 | |
| 21 | y, err := JSONToYAML(j) |
| 22 | if err != nil { |
| 23 | return nil, fmt.Errorf("error converting JSON to YAML: %v", err) |
| 24 | } |
| 25 | |
| 26 | return y, nil |
| 27 | } |
| 28 | |
| 29 | // Converts YAML to JSON then uses JSON to unmarshal into an object. |
| 30 | func Unmarshal(y []byte, o interface{}) error { |
| 31 | vo := reflect.ValueOf(o) |
| 32 | j, err := yamlToJSON(y, &vo) |
| 33 | if err != nil { |
| 34 | return fmt.Errorf("error converting YAML to JSON: %v", err) |
| 35 | } |
| 36 | |
| 37 | err = json.Unmarshal(j, o) |
| 38 | if err != nil { |
| 39 | return fmt.Errorf("error unmarshaling JSON: %v", err) |
| 40 | } |
| 41 | |
| 42 | return nil |
| 43 | } |
| 44 | |
| 45 | // Convert JSON to YAML. |
| 46 | func JSONToYAML(j []byte) ([]byte, error) { |
| 47 | // Convert the JSON to an object. |
| 48 | var jsonObj interface{} |
| 49 | // We are using yaml.Unmarshal here (instead of json.Unmarshal) because the |
| 50 | // Go JSON library doesn't try to pick the right number type (int, float, |
| 51 | // etc.) when unmarshalling to interface{}, it just picks float64 |
| 52 | // universally. go-yaml does go through the effort of picking the right |
| 53 | // number type, so we can preserve number type throughout this process. |
| 54 | err := yaml.Unmarshal(j, &jsonObj) |
| 55 | if err != nil { |
| 56 | return nil, err |
| 57 | } |
| 58 | |
| 59 | // Marshal this object into YAML. |
| 60 | return yaml.Marshal(jsonObj) |
| 61 | } |
| 62 | |
| 63 | // Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through |
| 64 | // this method should be a no-op. |
| 65 | // |
| 66 | // Things YAML can do that are not supported by JSON: |
| 67 | // * In YAML you can have binary and null keys in your maps. These are invalid |
| 68 | // in JSON. (int and float keys are converted to strings.) |
| 69 | // * Binary data in YAML with the !!binary tag is not supported. If you want to |
| 70 | // use binary data with this library, encode the data as base64 as usual but do |
| 71 | // not use the !!binary tag in your YAML. This will ensure the original base64 |
| 72 | // encoded data makes it all the way through to the JSON. |
| 73 | func YAMLToJSON(y []byte) ([]byte, error) { |
| 74 | return yamlToJSON(y, nil) |
| 75 | } |
| 76 | |
| 77 | func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) { |
| 78 | // Convert the YAML to an object. |
| 79 | var yamlObj interface{} |
| 80 | err := yaml.Unmarshal(y, &yamlObj) |
| 81 | if err != nil { |
| 82 | return nil, err |
| 83 | } |
| 84 | |
| 85 | // YAML objects are not completely compatible with JSON objects (e.g. you |
| 86 | // can have non-string keys in YAML). So, convert the YAML-compatible object |
| 87 | // to a JSON-compatible object, failing with an error if irrecoverable |
| 88 | // incompatibilties happen along the way. |
| 89 | jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget) |
| 90 | if err != nil { |
| 91 | return nil, err |
| 92 | } |
| 93 | |
| 94 | // Convert this object to JSON and return the data. |
| 95 | return json.Marshal(jsonObj) |
| 96 | } |
| 97 | |
| 98 | func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) { |
| 99 | var err error |
| 100 | |
| 101 | // Resolve jsonTarget to a concrete value (i.e. not a pointer or an |
| 102 | // interface). We pass decodingNull as false because we're not actually |
| 103 | // decoding into the value, we're just checking if the ultimate target is a |
| 104 | // string. |
| 105 | if jsonTarget != nil { |
| 106 | ju, tu, pv := indirect(*jsonTarget, false) |
| 107 | // We have a JSON or Text Umarshaler at this level, so we can't be trying |
| 108 | // to decode into a string. |
| 109 | if ju != nil || tu != nil { |
| 110 | jsonTarget = nil |
| 111 | } else { |
| 112 | jsonTarget = &pv |
| 113 | } |
| 114 | } |
| 115 | |
| 116 | // If yamlObj is a number or a boolean, check if jsonTarget is a string - |
| 117 | // if so, coerce. Else return normal. |
| 118 | // If yamlObj is a map or array, find the field that each key is |
| 119 | // unmarshaling to, and when you recurse pass the reflect.Value for that |
| 120 | // field back into this function. |
| 121 | switch typedYAMLObj := yamlObj.(type) { |
| 122 | case map[interface{}]interface{}: |
| 123 | // JSON does not support arbitrary keys in a map, so we must convert |
| 124 | // these keys to strings. |
| 125 | // |
| 126 | // From my reading of go-yaml v2 (specifically the resolve function), |
| 127 | // keys can only have the types string, int, int64, float64, binary |
| 128 | // (unsupported), or null (unsupported). |
| 129 | strMap := make(map[string]interface{}) |
| 130 | for k, v := range typedYAMLObj { |
| 131 | // Resolve the key to a string first. |
| 132 | var keyString string |
| 133 | switch typedKey := k.(type) { |
| 134 | case string: |
| 135 | keyString = typedKey |
| 136 | case int: |
| 137 | keyString = strconv.Itoa(typedKey) |
| 138 | case int64: |
| 139 | // go-yaml will only return an int64 as a key if the system |
| 140 | // architecture is 32-bit and the key's value is between 32-bit |
| 141 | // and 64-bit. Otherwise the key type will simply be int. |
| 142 | keyString = strconv.FormatInt(typedKey, 10) |
| 143 | case float64: |
| 144 | // Stolen from go-yaml to use the same conversion to string as |
| 145 | // the go-yaml library uses to convert float to string when |
| 146 | // Marshaling. |
| 147 | s := strconv.FormatFloat(typedKey, 'g', -1, 32) |
| 148 | switch s { |
| 149 | case "+Inf": |
| 150 | s = ".inf" |
| 151 | case "-Inf": |
| 152 | s = "-.inf" |
| 153 | case "NaN": |
| 154 | s = ".nan" |
| 155 | } |
| 156 | keyString = s |
| 157 | case bool: |
| 158 | if typedKey { |
| 159 | keyString = "true" |
| 160 | } else { |
| 161 | keyString = "false" |
| 162 | } |
| 163 | default: |
| 164 | return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v", |
| 165 | reflect.TypeOf(k), k, v) |
| 166 | } |
| 167 | |
| 168 | // jsonTarget should be a struct or a map. If it's a struct, find |
| 169 | // the field it's going to map to and pass its reflect.Value. If |
| 170 | // it's a map, find the element type of the map and pass the |
| 171 | // reflect.Value created from that type. If it's neither, just pass |
| 172 | // nil - JSON conversion will error for us if it's a real issue. |
| 173 | if jsonTarget != nil { |
| 174 | t := *jsonTarget |
| 175 | if t.Kind() == reflect.Struct { |
| 176 | keyBytes := []byte(keyString) |
| 177 | // Find the field that the JSON library would use. |
| 178 | var f *field |
| 179 | fields := cachedTypeFields(t.Type()) |
| 180 | for i := range fields { |
| 181 | ff := &fields[i] |
| 182 | if bytes.Equal(ff.nameBytes, keyBytes) { |
| 183 | f = ff |
| 184 | break |
| 185 | } |
| 186 | // Do case-insensitive comparison. |
| 187 | if f == nil && ff.equalFold(ff.nameBytes, keyBytes) { |
| 188 | f = ff |
| 189 | } |
| 190 | } |
| 191 | if f != nil { |
| 192 | // Find the reflect.Value of the most preferential |
| 193 | // struct field. |
| 194 | jtf := t.Field(f.index[0]) |
| 195 | strMap[keyString], err = convertToJSONableObject(v, &jtf) |
| 196 | if err != nil { |
| 197 | return nil, err |
| 198 | } |
| 199 | continue |
| 200 | } |
| 201 | } else if t.Kind() == reflect.Map { |
| 202 | // Create a zero value of the map's element type to use as |
| 203 | // the JSON target. |
| 204 | jtv := reflect.Zero(t.Type().Elem()) |
| 205 | strMap[keyString], err = convertToJSONableObject(v, &jtv) |
| 206 | if err != nil { |
| 207 | return nil, err |
| 208 | } |
| 209 | continue |
| 210 | } |
| 211 | } |
| 212 | strMap[keyString], err = convertToJSONableObject(v, nil) |
| 213 | if err != nil { |
| 214 | return nil, err |
| 215 | } |
| 216 | } |
| 217 | return strMap, nil |
| 218 | case []interface{}: |
| 219 | // We need to recurse into arrays in case there are any |
| 220 | // map[interface{}]interface{}'s inside and to convert any |
| 221 | // numbers to strings. |
| 222 | |
| 223 | // If jsonTarget is a slice (which it really should be), find the |
| 224 | // thing it's going to map to. If it's not a slice, just pass nil |
| 225 | // - JSON conversion will error for us if it's a real issue. |
| 226 | var jsonSliceElemValue *reflect.Value |
| 227 | if jsonTarget != nil { |
| 228 | t := *jsonTarget |
| 229 | if t.Kind() == reflect.Slice { |
| 230 | // By default slices point to nil, but we need a reflect.Value |
| 231 | // pointing to a value of the slice type, so we create one here. |
| 232 | ev := reflect.Indirect(reflect.New(t.Type().Elem())) |
| 233 | jsonSliceElemValue = &ev |
| 234 | } |
| 235 | } |
| 236 | |
| 237 | // Make and use a new array. |
| 238 | arr := make([]interface{}, len(typedYAMLObj)) |
| 239 | for i, v := range typedYAMLObj { |
| 240 | arr[i], err = convertToJSONableObject(v, jsonSliceElemValue) |
| 241 | if err != nil { |
| 242 | return nil, err |
| 243 | } |
| 244 | } |
| 245 | return arr, nil |
| 246 | default: |
| 247 | // If the target type is a string and the YAML type is a number, |
| 248 | // convert the YAML type to a string. |
| 249 | if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String { |
| 250 | // Based on my reading of go-yaml, it may return int, int64, |
| 251 | // float64, or uint64. |
| 252 | var s string |
| 253 | switch typedVal := typedYAMLObj.(type) { |
| 254 | case int: |
| 255 | s = strconv.FormatInt(int64(typedVal), 10) |
| 256 | case int64: |
| 257 | s = strconv.FormatInt(typedVal, 10) |
| 258 | case float64: |
| 259 | s = strconv.FormatFloat(typedVal, 'g', -1, 32) |
| 260 | case uint64: |
| 261 | s = strconv.FormatUint(typedVal, 10) |
| 262 | case bool: |
| 263 | if typedVal { |
| 264 | s = "true" |
| 265 | } else { |
| 266 | s = "false" |
| 267 | } |
| 268 | } |
| 269 | if len(s) > 0 { |
| 270 | yamlObj = interface{}(s) |
| 271 | } |
| 272 | } |
| 273 | return yamlObj, nil |
| 274 | } |
| 275 | |
| 276 | return nil, nil |
| 277 | } |