diff --git a/cmd/helm/helm.go b/cmd/helm/helm.go index 7e1fcb6e1..2cdbe7396 100644 --- a/cmd/helm/helm.go +++ b/cmd/helm/helm.go @@ -27,7 +27,7 @@ import ( "github.com/spf13/cobra" "github.com/spf13/pflag" "k8s.io/klog" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" // Import to initialize client auth plugins. _ "k8s.io/client-go/plugin/pkg/client/auth" diff --git a/cmd/helm/load_plugins.go b/cmd/helm/load_plugins.go index e56feab40..58d830381 100644 --- a/cmd/helm/load_plugins.go +++ b/cmd/helm/load_plugins.go @@ -30,7 +30,7 @@ import ( "github.com/pkg/errors" "github.com/spf13/cobra" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/completion" "helm.sh/helm/v3/pkg/plugin" diff --git a/cmd/helm/repo_add.go b/cmd/helm/repo_add.go index 3d36fd0ed..dac2ea322 100644 --- a/cmd/helm/repo_add.go +++ b/cmd/helm/repo_add.go @@ -29,7 +29,7 @@ import ( "github.com/gofrs/flock" "github.com/pkg/errors" "github.com/spf13/cobra" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/cmd/helm/require" "helm.sh/helm/v3/pkg/getter" diff --git a/cmd/helm/repo_add_test.go b/cmd/helm/repo_add_test.go index d1b9bc0fc..8b63a5598 100644 --- a/cmd/helm/repo_add_test.go +++ b/cmd/helm/repo_add_test.go @@ -24,7 +24,7 @@ import ( "sync" "testing" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/test/ensure" "helm.sh/helm/v3/pkg/helmpath" diff --git a/go.mod b/go.mod index 64ebfe307..30d03ffba 100644 --- a/go.mod +++ b/go.mod @@ -34,6 +34,8 @@ require ( github.com/stretchr/testify v1.5.1 github.com/xeipuuv/gojsonschema v1.1.0 golang.org/x/crypto v0.0.0-20200414173820-0848c9571904 + gopkg.in/yaml.v2 v2.2.8 + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c k8s.io/api v0.18.0 k8s.io/apiextensions-apiserver v0.18.0 k8s.io/apimachinery v0.18.0 diff --git a/go.sum b/go.sum index 0a51a72e8..d389750da 100644 --- a/go.sum +++ b/go.sum @@ -732,6 +732,8 @@ gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/pkg/action/install.go b/pkg/action/install.go index 4b4dd9214..6d5b2f0f5 100644 --- a/pkg/action/install.go +++ b/pkg/action/install.go @@ -33,7 +33,7 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/cli-runtime/pkg/resource" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" "helm.sh/helm/v3/pkg/chartutil" diff --git a/pkg/action/show.go b/pkg/action/show.go index cc85477cd..60683bace 100644 --- a/pkg/action/show.go +++ b/pkg/action/show.go @@ -20,7 +20,7 @@ import ( "fmt" "strings" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" "helm.sh/helm/v3/pkg/chart/loader" diff --git a/pkg/chart/loader/load.go b/pkg/chart/loader/load.go index dd4fd2dff..3dbed7f6c 100644 --- a/pkg/chart/loader/load.go +++ b/pkg/chart/loader/load.go @@ -24,7 +24,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" ) diff --git a/pkg/chartutil/chartfile.go b/pkg/chartutil/chartfile.go index 808a902b1..a3619b5e3 100644 --- a/pkg/chartutil/chartfile.go +++ b/pkg/chartutil/chartfile.go @@ -22,7 +22,7 @@ import ( "path/filepath" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" ) diff --git a/pkg/chartutil/create.go b/pkg/chartutil/create.go index 28fb28e00..36d883676 100644 --- a/pkg/chartutil/create.go +++ b/pkg/chartutil/create.go @@ -24,7 +24,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" "helm.sh/helm/v3/pkg/chart/loader" diff --git a/pkg/chartutil/expand.go b/pkg/chartutil/expand.go index 6ad09e417..49e8028cc 100644 --- a/pkg/chartutil/expand.go +++ b/pkg/chartutil/expand.go @@ -24,8 +24,7 @@ import ( securejoin "github.com/cyphar/filepath-securejoin" "github.com/pkg/errors" - "sigs.k8s.io/yaml" - + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" "helm.sh/helm/v3/pkg/chart/loader" ) diff --git a/pkg/chartutil/jsonschema.go b/pkg/chartutil/jsonschema.go index 753dc98c1..224b1d127 100644 --- a/pkg/chartutil/jsonschema.go +++ b/pkg/chartutil/jsonschema.go @@ -23,9 +23,8 @@ import ( "github.com/pkg/errors" "github.com/xeipuuv/gojsonschema" - "sigs.k8s.io/yaml" - "helm.sh/helm/v3/pkg/chart" + "helm.sh/helm/v3/pkg/chartutil/yaml" ) // ValidateAgainstSchema checks that values does not violate the structure laid out in schema @@ -60,7 +59,7 @@ func ValidateAgainstSingleSchema(values Values, schemaJSON []byte) error { if err != nil { return err } - valuesJSON, err := yaml.YAMLToJSON(valuesData) + valuesJSON, err := yaml.ToJSON(valuesData) if err != nil { return err } diff --git a/pkg/chartutil/save.go b/pkg/chartutil/save.go index be5d151d7..88282e920 100644 --- a/pkg/chartutil/save.go +++ b/pkg/chartutil/save.go @@ -26,7 +26,7 @@ import ( "time" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" ) diff --git a/pkg/chartutil/values.go b/pkg/chartutil/values.go index e1cdf4642..b4b434268 100644 --- a/pkg/chartutil/values.go +++ b/pkg/chartutil/values.go @@ -23,7 +23,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart" ) diff --git a/pkg/chartutil/yaml/fields.go b/pkg/chartutil/yaml/fields.go new file mode 100644 index 000000000..586007402 --- /dev/null +++ b/pkg/chartutil/yaml/fields.go @@ -0,0 +1,501 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. +package yaml + +import ( + "bytes" + "encoding" + "encoding/json" + "reflect" + "sort" + "strings" + "sync" + "unicode" + "unicode/utf8" +) + +// indirect walks down v allocating pointers as needed, +// until it gets to a non-pointer. +// if it encounters an Unmarshaler, indirect stops and returns that. +// if decodingNull is true, indirect stops at the last pointer so it can be set to nil. +func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) { + // If v is a named type and is addressable, + // start with its address, so that if the type has pointer methods, + // we find them. + if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { + v = v.Addr() + } + for { + // Load value from interface, but only if the result will be + // usefully addressable. + if v.Kind() == reflect.Interface && !v.IsNil() { + e := v.Elem() + if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) { + v = e + continue + } + } + + if v.Kind() != reflect.Ptr { + break + } + + if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() { + break + } + if v.IsNil() { + if v.CanSet() { + v.Set(reflect.New(v.Type().Elem())) + } else { + v = reflect.New(v.Type().Elem()) + } + } + if v.Type().NumMethod() > 0 { + if u, ok := v.Interface().(json.Unmarshaler); ok { + return u, nil, reflect.Value{} + } + if u, ok := v.Interface().(encoding.TextUnmarshaler); ok { + return nil, u, reflect.Value{} + } + } + v = v.Elem() + } + return nil, nil, v +} + +// A field represents a single field found in a struct. +type field struct { + name string + nameBytes []byte // []byte(name) + equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent + + tag bool + index []int + typ reflect.Type + omitEmpty bool + quoted bool +} + +func fillField(f field) field { + f.nameBytes = []byte(f.name) + f.equalFold = foldFunc(f.nameBytes) + return f +} + +// byName sorts field by name, breaking ties with depth, +// then breaking ties with "name came from json tag", then +// breaking ties with index sequence. +type byName []field + +func (x byName) Len() int { return len(x) } + +func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byName) Less(i, j int) bool { + if x[i].name != x[j].name { + return x[i].name < x[j].name + } + if len(x[i].index) != len(x[j].index) { + return len(x[i].index) < len(x[j].index) + } + if x[i].tag != x[j].tag { + return x[i].tag + } + return byIndex(x).Less(i, j) +} + +// byIndex sorts field by index sequence. +type byIndex []field + +func (x byIndex) Len() int { return len(x) } + +func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byIndex) Less(i, j int) bool { + for k, xik := range x[i].index { + if k >= len(x[j].index) { + return false + } + if xik != x[j].index[k] { + return xik < x[j].index[k] + } + } + return len(x[i].index) < len(x[j].index) +} + +// typeFields returns a list of fields that JSON should recognize for the given type. +// The algorithm is breadth-first search over the set of structs to include - the top struct +// and then any reachable anonymous structs. +func typeFields(t reflect.Type) []field { + // Anonymous fields to explore at the current level and the next. + current := []field{} + next := []field{{typ: t}} + + // Count of queued names for current level and the next. + count := map[reflect.Type]int{} + nextCount := map[reflect.Type]int{} + + // Types already visited at an earlier level. + visited := map[reflect.Type]bool{} + + // Fields found. + var fields []field + + for len(next) > 0 { + current, next = next, current[:0] + count, nextCount = nextCount, map[reflect.Type]int{} + + for _, f := range current { + if visited[f.typ] { + continue + } + visited[f.typ] = true + + // Scan f.typ for fields to include. + for i := 0; i < f.typ.NumField(); i++ { + sf := f.typ.Field(i) + if sf.PkgPath != "" { // unexported + continue + } + tag := sf.Tag.Get("json") + if tag == "-" { + continue + } + name, opts := parseTag(tag) + if !isValidTag(name) { + name = "" + } + index := make([]int, len(f.index)+1) + copy(index, f.index) + index[len(f.index)] = i + + ft := sf.Type + if ft.Name() == "" && ft.Kind() == reflect.Ptr { + // Follow pointer. + ft = ft.Elem() + } + + // Record found field and index sequence. + if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { + tagged := name != "" + if name == "" { + name = sf.Name + } + fields = append(fields, fillField(field{ + name: name, + tag: tagged, + index: index, + typ: ft, + omitEmpty: opts.Contains("omitempty"), + quoted: opts.Contains("string"), + })) + if count[f.typ] > 1 { + // If there were multiple instances, add a second, + // so that the annihilation code will see a duplicate. + // It only cares about the distinction between 1 or 2, + // so don't bother generating any more copies. + fields = append(fields, fields[len(fields)-1]) + } + continue + } + + // Record new anonymous struct to explore in next round. + nextCount[ft]++ + if nextCount[ft] == 1 { + next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft})) + } + } + } + } + + sort.Sort(byName(fields)) + + // Delete all fields that are hidden by the Go rules for embedded fields, + // except that fields with JSON tags are promoted. + + // The fields are sorted in primary order of name, secondary order + // of field index length. Loop over names; for each name, delete + // hidden fields by choosing the one dominant field that survives. + out := fields[:0] + for advance, i := 0, 0; i < len(fields); i += advance { + // One iteration per name. + // Find the sequence of fields with the name of this first field. + fi := fields[i] + name := fi.name + for advance = 1; i+advance < len(fields); advance++ { + fj := fields[i+advance] + if fj.name != name { + break + } + } + if advance == 1 { // Only one field with this name + out = append(out, fi) + continue + } + dominant, ok := dominantField(fields[i : i+advance]) + if ok { + out = append(out, dominant) + } + } + + fields = out + sort.Sort(byIndex(fields)) + + return fields +} + +// dominantField looks through the fields, all of which are known to +// have the same name, to find the single field that dominates the +// others using Go's embedding rules, modified by the presence of +// JSON tags. If there are multiple top-level fields, the boolean +// will be false: This condition is an error in Go and we skip all +// the fields. +func dominantField(fields []field) (field, bool) { + // The fields are sorted in increasing index-length order. The winner + // must therefore be one with the shortest index length. Drop all + // longer entries, which is easy: just truncate the slice. + length := len(fields[0].index) + tagged := -1 // Index of first tagged field. + for i, f := range fields { + if len(f.index) > length { + fields = fields[:i] + break + } + if f.tag { + if tagged >= 0 { + // Multiple tagged fields at the same level: conflict. + // Return no field. + return field{}, false + } + tagged = i + } + } + if tagged >= 0 { + return fields[tagged], true + } + // All remaining fields have the same length. If there's more than one, + // we have a conflict (two fields named "X" at the same level) and we + // return no field. + if len(fields) > 1 { + return field{}, false + } + return fields[0], true +} + +var fieldCache struct { + sync.RWMutex + m map[reflect.Type][]field +} + +// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. +func cachedTypeFields(t reflect.Type) []field { + fieldCache.RLock() + f := fieldCache.m[t] + fieldCache.RUnlock() + if f != nil { + return f + } + + // Compute fields without lock. + // Might duplicate effort but won't hold other computations back. + f = typeFields(t) + if f == nil { + f = []field{} + } + + fieldCache.Lock() + if fieldCache.m == nil { + fieldCache.m = map[reflect.Type][]field{} + } + fieldCache.m[t] = f + fieldCache.Unlock() + return f +} + +func isValidTag(s string) bool { + if s == "" { + return false + } + for _, c := range s { + switch { + case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): + // Backslash and quote chars are reserved, but + // otherwise any punctuation chars are allowed + // in a tag name. + default: + if !unicode.IsLetter(c) && !unicode.IsDigit(c) { + return false + } + } + } + return true +} + +const ( + caseMask = ^byte(0x20) // Mask to ignore case in ASCII. + kelvin = '\u212a' + smallLongEss = '\u017f' +) + +// foldFunc returns one of four different case folding equivalence +// functions, from most general (and slow) to fastest: +// +// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8 +// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S') +// 3) asciiEqualFold, no special, but includes non-letters (including _) +// 4) simpleLetterEqualFold, no specials, no non-letters. +// +// The letters S and K are special because they map to 3 runes, not just 2: +// * S maps to s and to U+017F 'ſ' Latin small letter long s +// * k maps to K and to U+212A 'K' Kelvin sign +// See http://play.golang.org/p/tTxjOc0OGo +// +// The returned function is specialized for matching against s and +// should only be given s. It's not curried for performance reasons. +func foldFunc(s []byte) func(s, t []byte) bool { + nonLetter := false + special := false // special letter + for _, b := range s { + if b >= utf8.RuneSelf { + return bytes.EqualFold + } + upper := b & caseMask + if upper < 'A' || upper > 'Z' { + nonLetter = true + } else if upper == 'K' || upper == 'S' { + // See above for why these letters are special. + special = true + } + } + if special { + return equalFoldRight + } + if nonLetter { + return asciiEqualFold + } + return simpleLetterEqualFold +} + +// equalFoldRight is a specialization of bytes.EqualFold when s is +// known to be all ASCII (including punctuation), but contains an 's', +// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t. +// See comments on foldFunc. +func equalFoldRight(s, t []byte) bool { + for _, sb := range s { + if len(t) == 0 { + return false + } + tb := t[0] + if tb < utf8.RuneSelf { + if sb != tb { + sbUpper := sb & caseMask + if 'A' <= sbUpper && sbUpper <= 'Z' { + if sbUpper != tb&caseMask { + return false + } + } else { + return false + } + } + t = t[1:] + continue + } + // sb is ASCII and t is not. t must be either kelvin + // sign or long s; sb must be s, S, k, or K. + tr, size := utf8.DecodeRune(t) + switch sb { + case 's', 'S': + if tr != smallLongEss { + return false + } + case 'k', 'K': + if tr != kelvin { + return false + } + default: + return false + } + t = t[size:] + + } + if len(t) > 0 { + return false + } + return true +} + +// asciiEqualFold is a specialization of bytes.EqualFold for use when +// s is all ASCII (but may contain non-letters) and contains no +// special-folding letters. +// See comments on foldFunc. +func asciiEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, sb := range s { + tb := t[i] + if sb == tb { + continue + } + if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') { + if sb&caseMask != tb&caseMask { + return false + } + } else { + return false + } + } + return true +} + +// simpleLetterEqualFold is a specialization of bytes.EqualFold for +// use when s is all ASCII letters (no underscores, etc) and also +// doesn't contain 'k', 'K', 's', or 'S'. +// See comments on foldFunc. +func simpleLetterEqualFold(s, t []byte) bool { + if len(s) != len(t) { + return false + } + for i, b := range s { + if b&caseMask != t[i]&caseMask { + return false + } + } + return true +} + +// tagOptions is the string following a comma in a struct field's "json" +// tag, or the empty string. It does not include the leading comma. +type tagOptions string + +// parseTag splits a struct field's json tag into its name and +// comma-separated options. +func parseTag(tag string) (string, tagOptions) { + if idx := strings.Index(tag, ","); idx != -1 { + return tag[:idx], tagOptions(tag[idx+1:]) + } + return tag, tagOptions("") +} + +// Contains reports whether a comma-separated list of options +// contains a particular substr flag. substr must be surrounded by a +// string boundary or commas. +func (o tagOptions) Contains(optionName string) bool { + if len(o) == 0 { + return false + } + s := string(o) + for s != "" { + var next string + i := strings.Index(s, ",") + if i >= 0 { + s, next = s[:i], s[i+1:] + } + if s == optionName { + return true + } + s = next + } + return false +} diff --git a/pkg/chartutil/yaml/from_json.go b/pkg/chartutil/yaml/from_json.go new file mode 100644 index 000000000..f9d47b64a --- /dev/null +++ b/pkg/chartutil/yaml/from_json.go @@ -0,0 +1,21 @@ +package yaml + +import "gopkg.in/yaml.v2" + +// Convert JSON to YAML. +func FromJSON(j []byte) ([]byte, error) { + // Convert the JSON to an object. + var jsonObj interface{} + // We are using yaml.Unmarshal here (instead of json.Unmarshal) because the + // Go JSON library doesn't try to pick the right number type (int, float, + // etc.) when unmarshalling to interface{}, it just picks float64 + // universally. go-yaml does go through the effort of picking the right + // number type, so we can preserve number type throughout this process. + err := yaml.Unmarshal(j, &jsonObj) + if err != nil { + return nil, err + } + + // Marshal this object into YAML. + return yaml.Marshal(jsonObj) +} diff --git a/pkg/chartutil/yaml/marshal.go b/pkg/chartutil/yaml/marshal.go new file mode 100644 index 000000000..8636b2029 --- /dev/null +++ b/pkg/chartutil/yaml/marshal.go @@ -0,0 +1,5 @@ +package yaml + +import "gopkg.in/yaml.v3" + +var Marshal = yaml.Marshal diff --git a/pkg/chartutil/yaml/to_json.go b/pkg/chartutil/yaml/to_json.go new file mode 100644 index 000000000..288df67db --- /dev/null +++ b/pkg/chartutil/yaml/to_json.go @@ -0,0 +1,213 @@ +package yaml + +import ( + "bytes" + "encoding/json" + "fmt" + "reflect" + "strconv" + + "gopkg.in/yaml.v2" +) + +func ToJSON(y []byte) ([]byte, error) { + // Convert the YAML to an object. + var yamlObj interface{} + err := yaml.Unmarshal(y, &yamlObj) + if err != nil { + return nil, err + } + + // YAML objects are not completely compatible with JSON objects (e.g. you + // can have non-string keys in YAML). So, convert the YAML-compatible object + // to a JSON-compatible object, failing with an error if irrecoverable + // incompatibilities happen along the way. + jsonObj, err := convertToJSONableObject(yamlObj, nil) + if err != nil { + return nil, err + } + + // Convert this object to JSON and return the data. + return json.Marshal(jsonObj) +} + +func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) { + var err error + + // Resolve jsonTarget to a concrete value (i.e. not a pointer or an + // interface). We pass decodingNull as false because we're not actually + // decoding into the value, we're just checking if the ultimate target is a + // string. + if jsonTarget != nil { + ju, tu, pv := indirect(*jsonTarget, false) + // We have a JSON or Text Umarshaler at this level, so we can't be trying + // to decode into a string. + if ju != nil || tu != nil { + jsonTarget = nil + } else { + jsonTarget = &pv + } + } + + // If yamlObj is a number or a boolean, check if jsonTarget is a string - + // if so, coerce. Else return normal. + // If yamlObj is a map or array, find the field that each key is + // unmarshaling to, and when you recurse pass the reflect.Value for that + // field back into this function. + switch typedYAMLObj := yamlObj.(type) { + case map[interface{}]interface{}: + // JSON does not support arbitrary keys in a map, so we must convert + // these keys to strings. + // + // From my reading of go-yaml v2 (specifically the resolve function), + // keys can only have the types string, int, int64, float64, binary + // (unsupported), or null (unsupported). + strMap := make(map[string]interface{}) + for k, v := range typedYAMLObj { + // Resolve the key to a string first. + var keyString string + switch typedKey := k.(type) { + case string: + keyString = typedKey + case int: + keyString = strconv.Itoa(typedKey) + case int64: + // go-yaml will only return an int64 as a key if the system + // architecture is 32-bit and the key's value is between 32-bit + // and 64-bit. Otherwise the key type will simply be int. + keyString = strconv.FormatInt(typedKey, 10) + case float64: + // Stolen from go-yaml to use the same conversion to string as + // the go-yaml library uses to convert float to string when + // Marshaling. + s := strconv.FormatFloat(typedKey, 'g', -1, 32) + switch s { + case "+Inf": + s = ".inf" + case "-Inf": + s = "-.inf" + case "NaN": + s = ".nan" + } + keyString = s + case bool: + if typedKey { + keyString = "true" + } else { + keyString = "false" + } + default: + return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v", + reflect.TypeOf(k), k, v) + } + + // jsonTarget should be a struct or a map. If it's a struct, find + // the field it's going to map to and pass its reflect.Value. If + // it's a map, find the element type of the map and pass the + // reflect.Value created from that type. If it's neither, just pass + // nil - JSON conversion will error for us if it's a real issue. + if jsonTarget != nil { + t := *jsonTarget + if t.Kind() == reflect.Struct { + keyBytes := []byte(keyString) + // Find the field that the JSON library would use. + var f *field + fields := cachedTypeFields(t.Type()) + for i := range fields { + ff := &fields[i] + if bytes.Equal(ff.nameBytes, keyBytes) { + f = ff + break + } + // Do case-insensitive comparison. + if f == nil && ff.equalFold(ff.nameBytes, keyBytes) { + f = ff + } + } + if f != nil { + // Find the reflect.Value of the most preferential + // struct field. + jtf := t.Field(f.index[0]) + strMap[keyString], err = convertToJSONableObject(v, &jtf) + if err != nil { + return nil, err + } + continue + } + } else if t.Kind() == reflect.Map { + // Create a zero value of the map's element type to use as + // the JSON target. + jtv := reflect.Zero(t.Type().Elem()) + strMap[keyString], err = convertToJSONableObject(v, &jtv) + if err != nil { + return nil, err + } + continue + } + } + strMap[keyString], err = convertToJSONableObject(v, nil) + if err != nil { + return nil, err + } + } + return strMap, nil + case []interface{}: + // We need to recurse into arrays in case there are any + // map[interface{}]interface{}'s inside and to convert any + // numbers to strings. + + // If jsonTarget is a slice (which it really should be), find the + // thing it's going to map to. If it's not a slice, just pass nil + // - JSON conversion will error for us if it's a real issue. + var jsonSliceElemValue *reflect.Value + if jsonTarget != nil { + t := *jsonTarget + if t.Kind() == reflect.Slice { + // By default slices point to nil, but we need a reflect.Value + // pointing to a value of the slice type, so we create one here. + ev := reflect.Indirect(reflect.New(t.Type().Elem())) + jsonSliceElemValue = &ev + } + } + + // Make and use a new array. + arr := make([]interface{}, len(typedYAMLObj)) + for i, v := range typedYAMLObj { + arr[i], err = convertToJSONableObject(v, jsonSliceElemValue) + if err != nil { + return nil, err + } + } + return arr, nil + default: + // If the target type is a string and the YAML type is a number, + // convert the YAML type to a string. + if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String { + // Based on my reading of go-yaml, it may return int, int64, + // float64, or uint64. + var s string + switch typedVal := typedYAMLObj.(type) { + case int: + s = strconv.FormatInt(int64(typedVal), 10) + case int64: + s = strconv.FormatInt(typedVal, 10) + case float64: + s = strconv.FormatFloat(typedVal, 'g', -1, 32) + case uint64: + s = strconv.FormatUint(typedVal, 10) + case bool: + if typedVal { + s = "true" + } else { + s = "false" + } + } + if len(s) > 0 { + yamlObj = interface{}(s) + } + } + return yamlObj, nil + } + + return nil, nil +} diff --git a/pkg/chartutil/yaml/yaml.go b/pkg/chartutil/yaml/yaml.go new file mode 100644 index 000000000..1aabf141e --- /dev/null +++ b/pkg/chartutil/yaml/yaml.go @@ -0,0 +1,5 @@ +package yaml + +// This code was extracted from https://github.com/ghodss/yaml to provide the ToJSON (nee YAMLToJSON) functionality +// (being the only functionality needed above gopkg.in/yaml.v3. The reason for extraction was to upgrade to yaml.v3 +// but also to minimise dependency footprint. diff --git a/pkg/chartutil/yaml/yaml_test.go b/pkg/chartutil/yaml/yaml_test.go new file mode 100644 index 000000000..e0eb75fc5 --- /dev/null +++ b/pkg/chartutil/yaml/yaml_test.go @@ -0,0 +1,172 @@ +package yaml + +import ( + "testing" +) + +type Case struct { + input string + output string + // By default we test that reversing the output == input. But if there is a + // difference in the reversed output, you can optionally specify it here. + reverse *string +} + +type RunType int + +const ( + RunTypeJSONToYAML RunType = iota + RunTypeYAMLToJSON +) + +func TestJSONToYAML(t *testing.T) { + cases := []Case{ + { + `{"t":"a"}`, + "t: a\n", + nil, + }, { + `{"t":null}`, + "t: null\n", + nil, + }, + } + + runCases(t, RunTypeJSONToYAML, cases) +} + +func TestYAMLToJSON(t *testing.T) { + cases := []Case{ + { + "t: a\n", + `{"t":"a"}`, + nil, + }, { + "t: \n", + `{"t":null}`, + strPtr("t: null\n"), + }, { + "t: null\n", + `{"t":null}`, + nil, + }, { + "1: a\n", + `{"1":"a"}`, + strPtr("\"1\": a\n"), + }, { + "1000000000000000000000000000000000000: a\n", + `{"1e+36":"a"}`, + strPtr("\"1e+36\": a\n"), + }, { + "1e+36: a\n", + `{"1e+36":"a"}`, + strPtr("\"1e+36\": a\n"), + }, { + "\"1e+36\": a\n", + `{"1e+36":"a"}`, + nil, + }, { + "\"1.2\": a\n", + `{"1.2":"a"}`, + nil, + }, { + "- t: a\n", + `[{"t":"a"}]`, + nil, + }, { + "- t: a\n" + + "- t:\n" + + " b: 1\n" + + " c: 2\n", + `[{"t":"a"},{"t":{"b":1,"c":2}}]`, + nil, + }, { + `[{t: a}, {t: {b: 1, c: 2}}]`, + `[{"t":"a"},{"t":{"b":1,"c":2}}]`, + strPtr("- t: a\n" + + "- t:\n" + + " b: 1\n" + + " c: 2\n"), + }, { + "- t: \n", + `[{"t":null}]`, + strPtr("- t: null\n"), + }, { + "- t: null\n", + `[{"t":null}]`, + nil, + }, + } + + // Cases that should produce errors. + _ = []Case{ + { + "~: a", + `{"null":"a"}`, + nil, + }, { + "a: !!binary gIGC\n", + "{\"a\":\"\x80\x81\x82\"}", + nil, + }, + } + + runCases(t, RunTypeYAMLToJSON, cases) +} + +func runCases(t *testing.T, runType RunType, cases []Case) { + var f func([]byte) ([]byte, error) + var invF func([]byte) ([]byte, error) + var msg string + var invMsg string + if runType == RunTypeJSONToYAML { + f = FromJSON + invF = ToJSON + msg = "JSON to YAML" + invMsg = "YAML back to JSON" + } else { + f = ToJSON + invF = FromJSON + msg = "YAML to JSON" + invMsg = "JSON back to YAML" + } + + for _, c := range cases { + // Convert the string. + t.Logf("converting %s\n", c.input) + output, err := f([]byte(c.input)) + if err != nil { + t.Errorf("Failed to convert %s, input: `%s`, err: %v", msg, c.input, err) + } + + // Check it against the expected output. + if string(output) != c.output { + t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`", + msg, c.input, c.output, string(output)) + } + + // Set the string that we will compare the reversed output to. + reverse := c.input + // If a special reverse string was specified, use that instead. + if c.reverse != nil { + reverse = *c.reverse + } + + // Reverse the output. + input, err := invF(output) + if err != nil { + t.Errorf("Failed to convert %s, input: `%s`, err: %v", invMsg, string(output), err) + } + + // Check the reverse is equal to the input (or to *c.reverse). + if string(input) != reverse { + t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`", + invMsg, string(output), reverse, string(input)) + } + } +} + +// To be able to easily fill in the *Case.reverse string above. +func strPtr(s string) *string { + return &s +} diff --git a/pkg/cli/output/output.go b/pkg/cli/output/output.go index e4eb046fc..2ce0a22d7 100644 --- a/pkg/cli/output/output.go +++ b/pkg/cli/output/output.go @@ -23,7 +23,7 @@ import ( "github.com/gosuri/uitable" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" ) // Format is a type for capturing supported output formats diff --git a/pkg/cli/values/options.go b/pkg/cli/values/options.go index e6ad71767..dc7a0f0e3 100644 --- a/pkg/cli/values/options.go +++ b/pkg/cli/values/options.go @@ -23,7 +23,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/getter" "helm.sh/helm/v3/pkg/strvals" diff --git a/pkg/downloader/manager.go b/pkg/downloader/manager.go index 00198de0c..5dde0460e 100644 --- a/pkg/downloader/manager.go +++ b/pkg/downloader/manager.go @@ -29,7 +29,7 @@ import ( "github.com/Masterminds/semver/v3" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/resolver" "helm.sh/helm/v3/internal/third_party/dep/fs" diff --git a/pkg/engine/funcs.go b/pkg/engine/funcs.go index e5769cbe0..63ebea890 100644 --- a/pkg/engine/funcs.go +++ b/pkg/engine/funcs.go @@ -24,7 +24,7 @@ import ( "github.com/BurntSushi/toml" "github.com/Masterminds/sprig/v3" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" ) // funcMap returns a mapping of all of the functions that Engine has. diff --git a/pkg/lint/rules/template.go b/pkg/lint/rules/template.go index 3d388f81b..6a3c9d91e 100644 --- a/pkg/lint/rules/template.go +++ b/pkg/lint/rules/template.go @@ -22,7 +22,7 @@ import ( "regexp" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart/loader" "helm.sh/helm/v3/pkg/chartutil" diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go index 2eb354fca..337391e76 100644 --- a/pkg/plugin/plugin.go +++ b/pkg/plugin/plugin.go @@ -23,7 +23,7 @@ import ( "runtime" "strings" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/cli" ) diff --git a/pkg/provenance/sign.go b/pkg/provenance/sign.go index 5d16779f1..257304b3c 100644 --- a/pkg/provenance/sign.go +++ b/pkg/provenance/sign.go @@ -29,7 +29,7 @@ import ( "golang.org/x/crypto/openpgp" "golang.org/x/crypto/openpgp/clearsign" "golang.org/x/crypto/openpgp/packet" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" hapi "helm.sh/helm/v3/pkg/chart" "helm.sh/helm/v3/pkg/chart/loader" diff --git a/pkg/releaseutil/manifest_sorter.go b/pkg/releaseutil/manifest_sorter.go index e83414500..fb4d40ec6 100644 --- a/pkg/releaseutil/manifest_sorter.go +++ b/pkg/releaseutil/manifest_sorter.go @@ -24,7 +24,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chartutil" "helm.sh/helm/v3/pkg/release" diff --git a/pkg/releaseutil/manifest_sorter_test.go b/pkg/releaseutil/manifest_sorter_test.go index 20d809317..e0cdfa609 100644 --- a/pkg/releaseutil/manifest_sorter_test.go +++ b/pkg/releaseutil/manifest_sorter_test.go @@ -20,7 +20,7 @@ import ( "reflect" "testing" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chartutil" "helm.sh/helm/v3/pkg/release" diff --git a/pkg/repo/chartrepo.go b/pkg/repo/chartrepo.go index c2c366a1e..c8464f4e5 100644 --- a/pkg/repo/chartrepo.go +++ b/pkg/repo/chartrepo.go @@ -30,7 +30,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/chart/loader" "helm.sh/helm/v3/pkg/getter" diff --git a/pkg/repo/chartrepo_test.go b/pkg/repo/chartrepo_test.go index f50d6a2b6..8ef3ddac0 100644 --- a/pkg/repo/chartrepo_test.go +++ b/pkg/repo/chartrepo_test.go @@ -28,7 +28,7 @@ import ( "testing" "time" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/test/ensure" "helm.sh/helm/v3/pkg/chart" diff --git a/pkg/repo/index.go b/pkg/repo/index.go index 36386665e..d62705037 100644 --- a/pkg/repo/index.go +++ b/pkg/repo/index.go @@ -27,7 +27,7 @@ import ( "github.com/Masterminds/semver/v3" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/urlutil" "helm.sh/helm/v3/pkg/chart" diff --git a/pkg/repo/repo.go b/pkg/repo/repo.go index 6f1e90dad..7a6926e68 100644 --- a/pkg/repo/repo.go +++ b/pkg/repo/repo.go @@ -23,7 +23,7 @@ import ( "time" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" ) // File represents the repositories.yaml file diff --git a/pkg/repo/repotest/server.go b/pkg/repo/repotest/server.go index b18bce49c..0022f82aa 100644 --- a/pkg/repo/repotest/server.go +++ b/pkg/repo/repotest/server.go @@ -24,7 +24,7 @@ import ( "helm.sh/helm/v3/internal/tlsutil" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/pkg/repo" ) diff --git a/pkg/repo/repotest/server_test.go b/pkg/repo/repotest/server_test.go index ee62791af..e813bbda1 100644 --- a/pkg/repo/repotest/server_test.go +++ b/pkg/repo/repotest/server_test.go @@ -21,7 +21,7 @@ import ( "path/filepath" "testing" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" "helm.sh/helm/v3/internal/test/ensure" "helm.sh/helm/v3/pkg/repo" diff --git a/pkg/strvals/parser.go b/pkg/strvals/parser.go index 03adbd3cb..815a37c8e 100644 --- a/pkg/strvals/parser.go +++ b/pkg/strvals/parser.go @@ -22,7 +22,7 @@ import ( "strings" "github.com/pkg/errors" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" ) // ErrNotList indicates that a non-list was treated as a list. diff --git a/pkg/strvals/parser_test.go b/pkg/strvals/parser_test.go index 44d317220..bd71ebd57 100644 --- a/pkg/strvals/parser_test.go +++ b/pkg/strvals/parser_test.go @@ -18,7 +18,7 @@ package strvals import ( "testing" - "sigs.k8s.io/yaml" + "gopkg.in/yaml.v3" ) func TestSetIndex(t *testing.T) {