chore: fixes

Signed-off-by: George Jenkins <gvjenkins@gmail.com>
pull/31858/head
George Jenkins 2 days ago
parent ee018608f6
commit 92b64e87ad
No known key found for this signature in database
GPG Key ID: D79D67C9EC016739

@ -49,7 +49,7 @@ type Chart struct {
// Schema is an optional JSON schema for imposing structure on Values
Schema []byte `json:"schema"`
// SchemaModTime the schema was last modified
SchemaModTime time.Time `json:"schemamodtime,omitempty"`
SchemaModTime time.Time `json:"schemamodtime"`
// Files are miscellaneous files in a chart archive,
// e.g. README, LICENSE, etc.
Files []*common.File `json:"files"`

@ -63,7 +63,7 @@ func TestLoadDependency(t *testing.T) {
}
func TestDependencyEnabled(t *testing.T) {
type M = map[string]interface{}
type M = map[string]any
tests := []struct {
name string
v M

@ -153,7 +153,7 @@ func TestSavePreservesTimestamps(t *testing.T) {
Version: "1.2.3",
},
ModTime: initialCreateTime,
Values: map[string]interface{}{
Values: map[string]any{
"imageName": "testimage",
"imageId": 42,
},

@ -86,7 +86,7 @@ type Hook struct {
// Events are the events that this hook fires on.
Events []HookEvent `json:"events,omitempty"`
// LastRun indicates the date/time this was last run.
LastRun HookExecution `json:"last_run,omitempty"`
LastRun HookExecution `json:"last_run"`
// Weight indicates the sort order for execution among similar Hook type
Weight int `json:"weight,omitempty"`
// DeletePolicies are the policies that indicate when to delete the hook
@ -133,7 +133,7 @@ type hookExecutionJSON struct {
// It handles empty string time fields by treating them as zero values.
func (h *HookExecution) UnmarshalJSON(data []byte) error {
// First try to unmarshal into a map to handle empty string time fields
var raw map[string]interface{}
var raw map[string]any
if err := json.Unmarshal(data, &raw); err != nil {
return err
}

@ -220,7 +220,7 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
data, err := json.Marshal(&exec)
require.NoError(t, err)
var result map[string]interface{}
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)

@ -57,7 +57,7 @@ type infoJSON struct {
// It handles empty string time fields by treating them as zero values.
func (i *Info) UnmarshalJSON(data []byte) error {
// First try to unmarshal into a map to handle empty string time fields
var raw map[string]interface{}
var raw map[string]any
if err := json.Unmarshal(data, &raw); err != nil {
return err
}

@ -272,7 +272,7 @@ func TestInfoEmptyStringRoundTrip(t *testing.T) {
data, err := json.Marshal(&info)
require.NoError(t, err)
var result map[string]interface{}
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)

@ -124,7 +124,7 @@ func Mock(opts *MockReleaseOptions) *Release {
Name: name,
Info: info,
Chart: ch,
Config: map[string]interface{}{"name": "value"},
Config: map[string]any{"name": "value"},
Version: version,
Namespace: namespace,
Hooks: []*Hook{

@ -36,7 +36,7 @@ type Release struct {
Chart *chart.Chart `json:"chart,omitempty"`
// Config is the set of extra Values added to the chart.
// These values override the default values inside of the chart.
Config map[string]interface{} `json:"config,omitempty"`
Config map[string]any `json:"config,omitempty"`
// Manifest is the string representation of the rendered template.
Manifest string `json:"manifest,omitempty"`
// Hooks are all of the hooks declared for this release.

@ -137,7 +137,7 @@ func sortHooksByKind(hooks []*release.Hook, ordering KindSortOrder) []*release.H
return h
}
func lessByKind(_ interface{}, _ interface{}, kindA string, kindB string, o KindSortOrder) bool {
func lessByKind(_ any, _ any, kindA string, kindB string, o KindSortOrder) bool {
ordering := make(map[string]int, len(o))
for v, k := range o {
ordering[k] = v

@ -466,7 +466,7 @@ func GetVersionSet(client discovery.ServerResourcesInterface) (common.VersionSet
return common.DefaultVersionSet, nil
}
versionMap := make(map[string]interface{})
versionMap := make(map[string]any)
var versions []string
// Extract the groups

@ -157,12 +157,12 @@ func withName(name string) chartOption {
}
func withSampleValues() chartOption {
values := map[string]interface{}{
values := map[string]any{
"someKey": "someValue",
"nestedKey": map[string]interface{}{
"nestedKey": map[string]any{
"simpleKey": "simpleValue",
"anotherNestedKey": map[string]interface{}{
"yetAnotherNestedKey": map[string]interface{}{
"anotherNestedKey": map[string]any{
"yetAnotherNestedKey": map[string]any{
"youReadyForAnotherNestedKey": "No",
},
},
@ -173,7 +173,7 @@ func withSampleValues() chartOption {
}
}
func withValues(values map[string]interface{}) chartOption {
func withValues(values map[string]any) chartOption {
return func(opts *chartOptions) {
opts.Values = values
}
@ -274,7 +274,7 @@ func namedReleaseStub(name string, status rcommon.Status) *release.Release {
Description: "Named Release Stub",
},
Chart: buildChart(withSampleTemplates()),
Config: map[string]interface{}{"name": "value"},
Config: map[string]any{"name": "value"},
Version: 1,
Hooks: []*release.Hook{
{
@ -304,7 +304,7 @@ func TestConfiguration_Init(t *testing.T) {
tests := []struct {
name string
helmDriver string
expectedDriverType interface{}
expectedDriverType any
expectErr bool
errMsg string
}{
@ -795,7 +795,7 @@ func TestRenderResources_PostRenderer_Success(t *testing.T) {
}
ch := buildChart(withSampleTemplates())
values := map[string]interface{}{}
values := map[string]any{}
hooks, buf, notes, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,
@ -838,7 +838,7 @@ func TestRenderResources_PostRenderer_Error(t *testing.T) {
}
ch := buildChart(withSampleTemplates())
values := map[string]interface{}{}
values := map[string]any{}
_, _, _, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,
@ -866,7 +866,7 @@ func TestRenderResources_PostRenderer_MergeError(t *testing.T) {
{Name: "templates/invalid", ModTime: time.Now(), Data: []byte("invalid: yaml: content:")},
},
}
values := map[string]interface{}{}
values := map[string]any{}
_, _, _, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,
@ -888,7 +888,7 @@ func TestRenderResources_PostRenderer_SplitError(t *testing.T) {
}
ch := buildChart(withSampleTemplates())
values := map[string]interface{}{}
values := map[string]any{}
_, _, _, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,
@ -909,7 +909,7 @@ func TestRenderResources_PostRenderer_Integration(t *testing.T) {
}
ch := buildChart(withSampleTemplates())
values := map[string]interface{}{}
values := map[string]any{}
hooks, buf, notes, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,
@ -945,7 +945,7 @@ func TestRenderResources_NoPostRenderer(t *testing.T) {
cfg := actionConfigFixture(t)
ch := buildChart(withSampleTemplates())
values := map[string]interface{}{}
values := map[string]any{}
hooks, buf, notes, err := cfg.renderResources(
ch, values, "test-release", "", false, false, false,

@ -42,7 +42,7 @@ func NewGetValues(cfg *Configuration) *GetValues {
}
// Run executes 'helm get values' against the given release.
func (g *GetValues) Run(name string) (map[string]interface{}, error) {
func (g *GetValues) Run(name string) (map[string]any, error) {
if err := g.cfg.KubeClient.IsReachable(); err != nil {
return nil, err
}

@ -45,12 +45,12 @@ func TestGetValues_Run_UserConfigOnly(t *testing.T) {
client := NewGetValues(cfg)
releaseName := "test-release"
userConfig := map[string]interface{}{
"database": map[string]interface{}{
userConfig := map[string]any{
"database": map[string]any{
"host": "localhost",
"port": 5432,
},
"app": map[string]interface{}{
"app": map[string]any{
"name": "my-app",
"replicas": 3,
},
@ -66,9 +66,9 @@ func TestGetValues_Run_UserConfigOnly(t *testing.T) {
Name: "test-chart",
Version: "1.0.0",
},
Values: map[string]interface{}{
Values: map[string]any{
"defaultKey": "defaultValue",
"app": map[string]interface{}{
"app": map[string]any{
"name": "default-app",
"timeout": 30,
},
@ -92,19 +92,19 @@ func TestGetValues_Run_AllValues(t *testing.T) {
client.AllValues = true
releaseName := "test-release"
userConfig := map[string]interface{}{
"database": map[string]interface{}{
userConfig := map[string]any{
"database": map[string]any{
"host": "localhost",
"port": 5432,
},
"app": map[string]interface{}{
"app": map[string]any{
"name": "my-app",
},
}
chartDefaultValues := map[string]interface{}{
chartDefaultValues := map[string]any{
"defaultKey": "defaultValue",
"app": map[string]interface{}{
"app": map[string]any{
"name": "default-app",
"timeout": 30,
},
@ -132,11 +132,11 @@ func TestGetValues_Run_AllValues(t *testing.T) {
result, err := client.Run(releaseName)
require.NoError(t, err)
assert.Equal(t, "my-app", result["app"].(map[string]interface{})["name"])
assert.Equal(t, 30, result["app"].(map[string]interface{})["timeout"])
assert.Equal(t, "my-app", result["app"].(map[string]any)["name"])
assert.Equal(t, 30, result["app"].(map[string]any)["timeout"])
assert.Equal(t, "defaultValue", result["defaultKey"])
assert.Equal(t, "localhost", result["database"].(map[string]interface{})["host"])
assert.Equal(t, 5432, result["database"].(map[string]interface{})["port"])
assert.Equal(t, "localhost", result["database"].(map[string]any)["host"])
assert.Equal(t, 5432, result["database"].(map[string]any)["port"])
}
func TestGetValues_Run_EmptyValues(t *testing.T) {
@ -156,7 +156,7 @@ func TestGetValues_Run_EmptyValues(t *testing.T) {
Version: "1.0.0",
},
},
Config: map[string]interface{}{},
Config: map[string]any{},
Version: 1,
Namespace: "default",
}
@ -165,7 +165,7 @@ func TestGetValues_Run_EmptyValues(t *testing.T) {
result, err := client.Run(releaseName)
require.NoError(t, err)
assert.Equal(t, map[string]interface{}{}, result)
assert.Equal(t, map[string]any{}, result)
}
func TestGetValues_Run_UnreachableKubeClient(t *testing.T) {

@ -186,7 +186,7 @@ func runInstallForHooksWithSuccess(t *testing.T, manifest, expectedNamespace str
{Name: "templates/hello", ModTime: modTime, Data: []byte("hello: world")},
{Name: "templates/hooks", ModTime: modTime, Data: []byte(manifest)},
}
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChartWithTemplates(templates), vals)
is.NoError(err)
@ -216,7 +216,7 @@ func runInstallForHooksWithFailure(t *testing.T, manifest, expectedNamespace str
{Name: "templates/hello", ModTime: modTime, Data: []byte("hello: world")},
{Name: "templates/hooks", ModTime: modTime, Data: []byte(manifest)},
}
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChartWithTemplates(templates), vals)
is.Error(err)

@ -182,7 +182,7 @@ func TestInstallRelease(t *testing.T) {
req := require.New(t)
instAction := installAction(t)
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, done := context.WithCancel(t.Context())
resi, err := instAction.RunWithContext(ctx, buildChart(), vals)
if err != nil {
@ -288,13 +288,13 @@ func TestInstallReleaseWithTakeOwnership_ResourceOwnedNoFlag(t *testing.T) {
func TestInstallReleaseWithValues(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
userVals := map[string]interface{}{
"nestedKey": map[string]interface{}{
userVals := map[string]any{
"nestedKey": map[string]any{
"simpleKey": "simpleValue",
},
}
expectedUserValues := map[string]interface{}{
"nestedKey": map[string]interface{}{
expectedUserValues := map[string]any{
"nestedKey": map[string]any{
"simpleKey": "simpleValue",
},
}
@ -328,7 +328,7 @@ func TestInstallReleaseWithValues(t *testing.T) {
func TestInstallRelease_NoName(t *testing.T) {
instAction := installAction(t)
instAction.ReleaseName = ""
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := instAction.Run(buildChart(), vals)
if err == nil {
t.Fatal("expected failure when no name is specified")
@ -340,7 +340,7 @@ func TestInstallRelease_WithNotes(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
instAction.ReleaseName = "with-notes"
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withNotes("note here")), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -371,7 +371,7 @@ func TestInstallRelease_WithNotesRendered(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
instAction.ReleaseName = "with-notes"
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withNotes("got-{{.Release.Name}}")), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -394,7 +394,7 @@ func TestInstallRelease_WithChartAndDependencyParentNotes(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
instAction.ReleaseName = "with-notes"
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withNotes("parent"), withDependency(withNotes("child"))), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -417,7 +417,7 @@ func TestInstallRelease_WithChartAndDependencyAllNotes(t *testing.T) {
instAction := installAction(t)
instAction.ReleaseName = "with-notes"
instAction.SubNotes = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withNotes("parent"), withDependency(withNotes("child"))), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -443,7 +443,7 @@ func TestInstallRelease_DryRunClient(t *testing.T) {
instAction := installAction(t)
instAction.DryRunStrategy = dryRunStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withSampleTemplates()), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -471,7 +471,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
// First perform a normal dry-run with the secret and confirm its presence.
instAction.DryRunStrategy = DryRunClient
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -486,7 +486,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
// Perform a dry-run where the secret should not be present
instAction.HideSecret = true
vals = map[string]interface{}{}
vals = map[string]any{}
res2i, err := instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -502,7 +502,7 @@ func TestInstallRelease_DryRunHiddenSecret(t *testing.T) {
// Ensure there is an error when HideSecret True but not in a dry-run mode
instAction.DryRunStrategy = DryRunNone
vals = map[string]interface{}{}
vals = map[string]any{}
_, err = instAction.Run(buildChart(withSampleSecret(), withSampleTemplates()), vals)
if err == nil {
t.Fatalf("Did not get expected an error when dry-run false and hide secret is true")
@ -514,7 +514,7 @@ func TestInstallRelease_DryRun_Lookup(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
instAction.DryRunStrategy = DryRunNone
vals := map[string]interface{}{}
vals := map[string]any{}
mockChart := buildChart(withSampleTemplates())
mockChart.Templates = append(mockChart.Templates, &common.File{
@ -537,7 +537,7 @@ func TestInstallReleaseIncorrectTemplate_DryRun(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
instAction.DryRunStrategy = DryRunNone
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := instAction.Run(buildChart(withSampleIncludingIncorrectTemplates()), vals)
expectedErr := `hello/templates/incorrect:1:10
executing "hello/templates/incorrect" at <.Values.bad.doh>:
@ -555,7 +555,7 @@ func TestInstallRelease_NoHooks(t *testing.T) {
instAction.ReleaseName = "no-hooks"
require.NoError(t, instAction.cfg.Releases.Create(releaseStub()))
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(), vals)
if err != nil {
t.Fatalf("Failed install: %s", err)
@ -576,7 +576,7 @@ func TestInstallRelease_FailedHooks(t *testing.T) {
outBuffer := &bytes.Buffer{}
failer.PrintingKubeClient = kubefake.PrintingKubeClient{Out: io.Discard, LogOutput: outBuffer}
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(), vals)
is.Error(err)
res, err := releaserToV1Release(resi)
@ -596,7 +596,7 @@ func TestInstallRelease_ReplaceRelease(t *testing.T) {
require.NoError(t, instAction.cfg.Releases.Create(rel))
instAction.ReleaseName = rel.Name
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(), vals)
is.NoError(err)
res, err := releaserToV1Release(resi)
@ -616,13 +616,13 @@ func TestInstallRelease_ReplaceRelease(t *testing.T) {
func TestInstallRelease_KubeVersion(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := instAction.Run(buildChart(withKube(">=0.0.0")), vals)
is.NoError(err)
// This should fail for a few hundred years
instAction.ReleaseName = "should-fail"
vals = map[string]interface{}{}
vals = map[string]any{}
_, err = instAction.Run(buildChart(withKube(">=99.0.0")), vals)
is.Error(err)
is.Contains(err.Error(), "chart requires kubeVersion: >=99.0.0 which is incompatible with Kubernetes v1.20.")
@ -636,7 +636,7 @@ func TestInstallRelease_Wait(t *testing.T) {
failer.WaitError = fmt.Errorf("I timed out")
instAction.cfg.KubeClient = failer
instAction.WaitStrategy = kube.StatusWatcherStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
goroutines := instAction.getGoroutineCount()
@ -657,7 +657,7 @@ func TestInstallRelease_Wait_Interrupted(t *testing.T) {
failer.WaitDuration = 10 * time.Second
instAction.cfg.KubeClient = failer
instAction.WaitStrategy = kube.StatusWatcherStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, cancel := context.WithCancel(t.Context())
time.AfterFunc(time.Second, cancel)
@ -681,7 +681,7 @@ func TestInstallRelease_WaitForJobs(t *testing.T) {
instAction.cfg.KubeClient = failer
instAction.WaitStrategy = kube.StatusWatcherStrategy
instAction.WaitForJobs = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(), vals)
is.Error(err)
@ -704,7 +704,7 @@ func TestInstallRelease_RollbackOnFailure(t *testing.T) {
// disabling hooks to avoid an early fail when
// WaitForDelete is called on the pre-delete hook execution
instAction.DisableHooks = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := instAction.Run(buildChart(), vals)
is.Error(err)
@ -727,7 +727,7 @@ func TestInstallRelease_RollbackOnFailure(t *testing.T) {
failer.DeleteError = fmt.Errorf("uninstall fail")
instAction.cfg.KubeClient = failer
instAction.RollbackOnFailure = true
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := instAction.Run(buildChart(), vals)
is.Error(err)
@ -745,7 +745,7 @@ func TestInstallRelease_RollbackOnFailure_Interrupted(t *testing.T) {
failer.WaitDuration = 10 * time.Second
instAction.cfg.KubeClient = failer
instAction.RollbackOnFailure = true
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, cancel := context.WithCancel(t.Context())
time.AfterFunc(time.Second, cancel)
@ -841,7 +841,7 @@ func TestNameTemplate(t *testing.T) {
func TestInstallReleaseOutputDir(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
vals := map[string]interface{}{}
vals := map[string]any{}
dir := t.TempDir()
@ -873,7 +873,7 @@ func TestInstallReleaseOutputDir(t *testing.T) {
func TestInstallOutputDirWithReleaseName(t *testing.T) {
is := assert.New(t)
instAction := installAction(t)
vals := map[string]interface{}{}
vals := map[string]any{}
dir := t.TempDir()
@ -1290,7 +1290,7 @@ func TestInstallRelease_WaitOptionsPassedDownstream(t *testing.T) {
// Access the underlying FailingKubeClient to check recorded options
failer := instAction.cfg.KubeClient.(*kubefake.FailingKubeClient)
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := instAction.Run(buildChart(), vals)
is.NoError(err)

@ -53,7 +53,7 @@ func NewLint() *Lint {
}
// Run executes 'helm Lint' against the given chart.
func (l *Lint) Run(paths []string, vals map[string]interface{}) *LintResult {
func (l *Lint) Run(paths []string, vals map[string]any) *LintResult {
lowestTolerance := support.ErrorSev
if l.Strict {
lowestTolerance = support.WarningSev
@ -87,7 +87,7 @@ func HasWarningsOrErrors(result *LintResult) bool {
return len(result.Errors) > 0
}
func lintChart(path string, vals map[string]interface{}, namespace string, kubeVersion *common.KubeVersion, skipSchemaValidation bool) (support.Linter, error) {
func lintChart(path string, vals map[string]any, namespace string, kubeVersion *common.KubeVersion, skipSchemaValidation bool) (support.Linter, error) {
var chartPath string
linter := support.Linter{}

@ -26,7 +26,7 @@ import (
)
var (
values = make(map[string]interface{})
values = make(map[string]any)
namespace = "testNamespace"
chart1MultipleChartLint = "testdata/charts/multiplecharts-lint-chart-1"
chart2MultipleChartLint = "testdata/charts/multiplecharts-lint-chart-2"
@ -88,7 +88,7 @@ func TestLintChart(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := lintChart(tt.chartPath, map[string]interface{}{}, namespace, nil, tt.skipSchemaValidation)
_, err := lintChart(tt.chartPath, map[string]any{}, namespace, nil, tt.skipSchemaValidation)
switch {
case err != nil && !tt.err:
t.Errorf("%s", err)

@ -70,7 +70,7 @@ func NewPackage() *Package {
}
// Run executes 'helm package' against the given chart and returns the path to the packaged chart.
func (p *Package) Run(path string, _ map[string]interface{}) (string, error) {
func (p *Package) Run(path string, _ map[string]any) (string, error) {
chrt, err := loader.LoadDir(path)
if err != nil {
return "", err

@ -43,7 +43,7 @@ func TestShow(t *testing.T) {
Raw: []*common.File{
{Name: "values.yaml", ModTime: modTime, Data: []byte("VALUES\n")},
},
Values: map[string]interface{}{},
Values: map[string]any{},
}
output, err := client.Run("")

@ -60,7 +60,7 @@ func TestUpgradeRelease_Success(t *testing.T) {
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.WaitStrategy = kube.StatusWatcherStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, done := context.WithCancel(t.Context())
resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(), vals)
@ -94,7 +94,7 @@ func TestUpgradeRelease_Wait(t *testing.T) {
failer.WaitError = fmt.Errorf("I timed out")
upAction.cfg.KubeClient = failer
upAction.WaitStrategy = kube.StatusWatcherStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
@ -119,7 +119,7 @@ func TestUpgradeRelease_WaitForJobs(t *testing.T) {
upAction.cfg.KubeClient = failer
upAction.WaitStrategy = kube.StatusWatcherStrategy
upAction.WaitForJobs = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
@ -145,7 +145,7 @@ func TestUpgradeRelease_CleanupOnFail(t *testing.T) {
upAction.cfg.KubeClient = failer
upAction.WaitStrategy = kube.StatusWatcherStrategy
upAction.CleanupOnFail = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
@ -173,7 +173,7 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
failer.WatchUntilReadyError = fmt.Errorf("arming key removed")
upAction.cfg.KubeClient = failer
upAction.RollbackOnFailure = true
vals := map[string]interface{}{}
vals := map[string]any{}
resi, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
@ -202,7 +202,7 @@ func TestUpgradeRelease_RollbackOnFailure(t *testing.T) {
failer.UpdateError = fmt.Errorf("update fail")
upAction.cfg.KubeClient = failer
upAction.RollbackOnFailure = true
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := upAction.Run(rel.Name, buildChart(), vals)
req.Error(err)
@ -217,17 +217,17 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
t.Run("reuse values should work with values", func(t *testing.T) {
upAction := upgradeAction(t)
existingValues := map[string]interface{}{
existingValues := map[string]any{
"name": "value",
"maxHeapSize": "128m",
"replicas": 2,
}
newValues := map[string]interface{}{
newValues := map[string]any{
"name": "newValue",
"maxHeapSize": "512m",
"cpu": "12m",
}
expectedValues := map[string]interface{}{
expectedValues := map[string]any{
"name": "newValue",
"maxHeapSize": "512m",
"cpu": "12m",
@ -266,8 +266,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
t.Run("reuse values should not install disabled charts", func(t *testing.T) {
upAction := upgradeAction(t)
chartDefaultValues := map[string]interface{}{
"subchart": map[string]interface{}{
chartDefaultValues := map[string]any{
"subchart": map[string]any{
"enabled": true,
},
}
@ -283,8 +283,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
withMetadataDependency(dependency),
)
now := time.Now()
existingValues := map[string]interface{}{
"subchart": map[string]interface{}{
existingValues := map[string]any{
"subchart": map[string]any{
"enabled": false,
},
}
@ -311,7 +311,7 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
withMetadataDependency(dependency),
)
// reusing values and upgrading
resi, err := upAction.Run(rel.Name, sampleChartWithSubChart, map[string]interface{}{})
resi, err := upAction.Run(rel.Name, sampleChartWithSubChart, map[string]any{})
is.NoError(err)
res, err := releaserToV1Release(resi)
is.NoError(err)
@ -330,8 +330,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
is.Equal(common.StatusDeployed, updatedRes.Info.Status)
is.Equal(0, len(updatedRes.Chart.Dependencies()), "expected 0 dependencies")
expectedValues := map[string]interface{}{
"subchart": map[string]interface{}{
expectedValues := map[string]any{
"subchart": map[string]any{
"enabled": false,
},
}
@ -345,20 +345,20 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
t.Run("reset then reuse values should work with values", func(t *testing.T) {
upAction := upgradeAction(t)
existingValues := map[string]interface{}{
existingValues := map[string]any{
"name": "value",
"maxHeapSize": "128m",
"replicas": 2,
}
newValues := map[string]interface{}{
newValues := map[string]any{
"name": "newValue",
"maxHeapSize": "512m",
"cpu": "12m",
}
newChartValues := map[string]interface{}{
newChartValues := map[string]any{
"memory": "256m",
}
expectedValues := map[string]interface{}{
expectedValues := map[string]any{
"name": "newValue",
"maxHeapSize": "512m",
"cpu": "12m",
@ -411,7 +411,7 @@ func TestUpgradeRelease_Pending(t *testing.T) {
rel2.Version = 2
require.NoError(t, upAction.cfg.Releases.Create(rel2))
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := upAction.Run(rel.Name, buildChart(), vals)
req.Contains(err.Error(), "progress", err)
@ -431,7 +431,7 @@ func TestUpgradeRelease_Interrupted_Wait(t *testing.T) {
failer.WaitDuration = 10 * time.Second
upAction.cfg.KubeClient = failer
upAction.WaitStrategy = kube.StatusWatcherStrategy
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, cancel := context.WithCancel(t.Context())
time.AfterFunc(time.Second, cancel)
@ -460,7 +460,7 @@ func TestUpgradeRelease_Interrupted_RollbackOnFailure(t *testing.T) {
failer.WaitDuration = 5 * time.Second
upAction.cfg.KubeClient = failer
upAction.RollbackOnFailure = true
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, cancel := context.WithCancel(t.Context())
time.AfterFunc(time.Second, cancel)
@ -590,7 +590,7 @@ func TestUpgradeRelease_DryRun(t *testing.T) {
req.NoError(upAction.cfg.Releases.Create(rel))
upAction.DryRunStrategy = DryRunClient
vals := map[string]interface{}{}
vals := map[string]any{}
ctx, done := context.WithCancel(t.Context())
resi, err := upAction.RunWithContext(ctx, rel.Name, buildChart(withSampleSecret()), vals)
@ -610,7 +610,7 @@ func TestUpgradeRelease_DryRun(t *testing.T) {
// Test the case for hiding the secret to ensure it is not displayed
upAction.HideSecret = true
vals = map[string]interface{}{}
vals = map[string]any{}
ctx, done = context.WithCancel(t.Context())
resi, err = upAction.RunWithContext(ctx, rel.Name, buildChart(withSampleSecret()), vals)
@ -630,7 +630,7 @@ func TestUpgradeRelease_DryRun(t *testing.T) {
// Ensure in a dry run mode when using HideSecret
upAction.DryRunStrategy = DryRunNone
vals = map[string]interface{}{}
vals = map[string]any{}
ctx, done = context.WithCancel(t.Context())
_, err = upAction.RunWithContext(ctx, rel.Name, buildChart(withSampleSecret()), vals)
@ -752,7 +752,7 @@ func TestUpgradeRun_UnreachableKubeClient(t *testing.T) {
config.KubeClient = &failingKubeClient
client := NewUpgrade(config)
vals := map[string]interface{}{}
vals := map[string]any{}
result, err := client.Run("", buildChart(), vals)
assert.Nil(t, result)
@ -795,7 +795,7 @@ func TestUpgradeRelease_WaitOptionsPassedDownstream(t *testing.T) {
// Access the underlying FailingKubeClient to check recorded options
failer := upAction.cfg.KubeClient.(*kubefake.FailingKubeClient)
vals := map[string]interface{}{}
vals := map[string]any{}
_, err := upAction.Run(rel.Name, buildChart(), vals)
req.NoError(err)

@ -73,7 +73,7 @@ func newHTTPURLLoader() *HTTPURLLoader {
}
// ValidateAgainstSchema checks that values does not violate the structure laid out in schema
func ValidateAgainstSchema(ch chart.Charter, values map[string]interface{}) error {
func ValidateAgainstSchema(ch chart.Charter, values map[string]any) error {
chrt, err := chart.NewAccessor(ch)
if err != nil {
return err

@ -29,7 +29,7 @@ import (
const GlobalKey = "global"
// Values represents a collection of chart values.
type Values map[string]interface{}
type Values map[string]any
// YAML encodes the Values into a YAML string.
func (v Values) YAML() (string, error) {
@ -64,9 +64,9 @@ func (v Values) Table(name string) (Values, error) {
// AsMap is a utility function for converting Values to a map[string]interface{}.
//
// It protects against nil map panics.
func (v Values) AsMap() map[string]interface{} {
func (v Values) AsMap() map[string]any {
if len(v) == 0 {
return map[string]interface{}{}
return map[string]any{}
}
return v
}
@ -86,7 +86,7 @@ func tableLookup(v Values, simple string) (Values, error) {
if !ok {
return v, ErrNoTable{simple}
}
if vv, ok := v2.(map[string]interface{}); ok {
if vv, ok := v2.(map[string]any); ok {
return vv, nil
}
@ -113,7 +113,7 @@ func ReadValues(data []byte) (vals Values, err error) {
func ReadValuesFile(filename string) (Values, error) {
data, err := os.ReadFile(filename)
if err != nil {
return map[string]interface{}{}, err
return map[string]any{}, err
}
return ReadValues(data)
}
@ -129,8 +129,8 @@ type ReleaseOptions struct {
}
// istable is a special-purpose function to see if the present thing matches the definition of a YAML table.
func istable(v interface{}) bool {
_, ok := v.(map[string]interface{})
func istable(v any) bool {
_, ok := v.(map[string]any)
return ok
}
@ -141,14 +141,14 @@ func istable(v interface{}) bool {
// chapter:
// one:
// title: "Loomings"
func (v Values) PathValue(path string) (interface{}, error) {
func (v Values) PathValue(path string) (any, error) {
if path == "" {
return nil, errors.New("YAML path cannot be empty")
}
return v.pathValue(parsePath(path))
}
func (v Values) pathValue(path []string) (interface{}, error) {
func (v Values) pathValue(path []string) (any, error) {
if len(path) == 1 {
// if exists must be root key not table
if _, ok := v[path[0]]; ok && !istable(v[path[0]]) {

@ -135,7 +135,7 @@ chapter:
}
}
func matchValues(t *testing.T, data map[string]interface{}) {
func matchValues(t *testing.T, data map[string]any) {
t.Helper()
if data["poet"] != "Coleridge" {
t.Errorf("Unexpected poet: %s", data["poet"])
@ -160,7 +160,7 @@ func matchValues(t *testing.T, data map[string]interface{}) {
}
}
func ttpl(tpl string, v map[string]interface{}) (string, error) {
func ttpl(tpl string, v map[string]any) (string, error) {
var b bytes.Buffer
tt := template.Must(template.New("t").Parse(tpl))
err := tt.Execute(&b, v)

@ -48,11 +48,11 @@ type Chart struct {
// Templates for this chart.
Templates []*common.File `json:"templates"`
// Values are default config for this chart.
Values map[string]interface{} `json:"values"`
Values map[string]any `json:"values"`
// Schema is an optional JSON schema for imposing structure on Values
Schema []byte `json:"schema"`
// SchemaModTime the schema was last modified
SchemaModTime time.Time `json:"schemamodtime,omitempty"`
SchemaModTime time.Time `json:"schemamodtime"`
// Files are miscellaneous files in a chart archive,
// e.g. README, LICENSE, etc.
Files []*common.File `json:"files"`

@ -44,7 +44,7 @@ type Dependency struct {
Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
// ImportValues holds the mapping of source values to parent key to be imported. Each item can be a
// string or pair of child/parent sublist items.
ImportValues []interface{} `json:"import-values,omitempty" yaml:"import-values,omitempty"`
ImportValues []any `json:"import-values,omitempty" yaml:"import-values,omitempty"`
// Alias usable alias to be used for the chart
Alias string `json:"alias,omitempty" yaml:"alias,omitempty"`
}

@ -25,6 +25,6 @@ func (v ValidationError) Error() string {
}
// ValidationErrorf takes a message and formatting options and creates a ValidationError
func ValidationErrorf(msg string, args ...interface{}) ValidationError {
func ValidationErrorf(msg string, args ...any) ValidationError {
return ValidationError(fmt.Sprintf(msg, args...))
}

@ -43,7 +43,7 @@ func WithSkipSchemaValidation(skipSchemaValidation bool) LinterOption {
}
}
func RunAll(baseDir string, values map[string]interface{}, namespace string, options ...LinterOption) support.Linter {
func RunAll(baseDir string, values map[string]any, namespace string, options ...LinterOption) support.Linter {
chartDir, _ := filepath.Abs(baseDir)

@ -49,7 +49,7 @@ func TestValidateAllowedExtension(t *testing.T) {
}
}
var values = map[string]interface{}{"nameOverride": "", "httpPort": 80}
var values = map[string]any{"nameOverride": "", "httpPort": 80}
const namespace = "testNamespace"
@ -264,7 +264,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
APIVersion: "v2",
Version: "0.1.0",
},
Values: map[string]interface{}{
Values: map[string]any{
"mymap": map[string]string{
"key1": "val1",
},

@ -508,7 +508,7 @@ func TestLoadInvalidArchive(t *testing.T) {
func TestLoadValues(t *testing.T) {
testCases := map[string]struct {
data []byte
expctedValues map[string]interface{}
expctedValues map[string]any
}{
"It should load values correctly": {
data: []byte(`
@ -517,11 +517,11 @@ foo:
bar:
version: v2
`),
expctedValues: map[string]interface{}{
"foo": map[string]interface{}{
expctedValues: map[string]any{
"foo": map[string]any{
"image": "foo:v1",
},
"bar": map[string]interface{}{
"bar": map[string]any{
"version": "v2",
},
},
@ -536,11 +536,11 @@ bar:
foo:
image: foo:v2
`),
expctedValues: map[string]interface{}{
"foo": map[string]interface{}{
expctedValues: map[string]any{
"foo": map[string]any{
"image": "foo:v2",
},
"bar": map[string]interface{}{
"bar": map[string]any{
"version": "v2",
},
},
@ -560,24 +560,24 @@ foo:
}
func TestMergeValuesV2(t *testing.T) {
nestedMap := map[string]interface{}{
nestedMap := map[string]any{
"foo": "bar",
"baz": map[string]string{
"cool": "stuff",
},
}
anotherNestedMap := map[string]interface{}{
anotherNestedMap := map[string]any{
"foo": "bar",
"baz": map[string]string{
"cool": "things",
"awesome": "stuff",
},
}
flatMap := map[string]interface{}{
flatMap := map[string]any{
"foo": "bar",
"baz": "stuff",
}
anotherFlatMap := map[string]interface{}{
anotherFlatMap := map[string]any{
"testing": "fun",
}
@ -600,7 +600,7 @@ func TestMergeValuesV2(t *testing.T) {
}
testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
expectedMap := map[string]interface{}{
expectedMap := map[string]any{
"testing": "fun",
"foo": "bar",
"baz": map[string]string{

@ -142,7 +142,7 @@ func copyMetadata(metadata *chart.Metadata) *chart.Metadata {
}
// processDependencyEnabled removes disabled charts from dependencies
func processDependencyEnabled(c *chart.Chart, v map[string]interface{}, path string) error {
func processDependencyEnabled(c *chart.Chart, v map[string]any, path string) error {
if c.Metadata.Dependencies == nil {
return nil
}
@ -228,7 +228,7 @@ Loop:
}
// pathToMap creates a nested map given a YAML path in dot notation.
func pathToMap(path string, data map[string]interface{}) map[string]interface{} {
func pathToMap(path string, data map[string]any) map[string]any {
if path == "." {
return data
}
@ -237,13 +237,13 @@ func pathToMap(path string, data map[string]interface{}) map[string]interface{}
func parsePath(key string) []string { return strings.Split(key, ".") }
func set(path []string, data map[string]interface{}) map[string]interface{} {
func set(path []string, data map[string]any) map[string]any {
if len(path) == 0 {
return nil
}
cur := data
for i := len(path) - 1; i >= 0; i-- {
cur = map[string]interface{}{path[i]: cur}
cur = map[string]any{path[i]: cur}
}
return cur
}
@ -264,13 +264,13 @@ func processImportValues(c *chart.Chart, merge bool) error {
if err != nil {
return err
}
b := make(map[string]interface{})
b := make(map[string]any)
// import values from each dependency if specified in import-values
for _, r := range c.Metadata.Dependencies {
var outiv []interface{}
var outiv []any
for _, riv := range r.ImportValues {
switch iv := riv.(type) {
case map[string]interface{}:
case map[string]any:
child := fmt.Sprintf("%v", iv["child"])
parent := fmt.Sprintf("%v", iv["parent"])
@ -337,27 +337,27 @@ func processImportValues(c *chart.Chart, merge bool) error {
return nil
}
func deepCopyMap(vals map[string]interface{}) map[string]interface{} {
func deepCopyMap(vals map[string]any) map[string]any {
valsCopy, err := copystructure.Copy(vals)
if err != nil {
return vals
}
return valsCopy.(map[string]interface{})
return valsCopy.(map[string]any)
}
func trimNilValues(vals map[string]interface{}) map[string]interface{} {
func trimNilValues(vals map[string]any) map[string]any {
valsCopy, err := copystructure.Copy(vals)
if err != nil {
return vals
}
valsCopyMap := valsCopy.(map[string]interface{})
valsCopyMap := valsCopy.(map[string]any)
for key, val := range valsCopyMap {
if val == nil {
// Iterate over the values and remove nil keys
delete(valsCopyMap, key)
} else if istable(val) {
// Recursively call into ourselves to remove keys from inner tables
valsCopyMap[key] = trimNilValues(val.(map[string]interface{}))
valsCopyMap[key] = trimNilValues(val.(map[string]any))
}
}
@ -365,8 +365,8 @@ func trimNilValues(vals map[string]interface{}) map[string]interface{} {
}
// istable is a special-purpose function to see if the present thing matches the definition of a YAML table.
func istable(v interface{}) bool {
_, ok := v.(map[string]interface{})
func istable(v any) bool {
_, ok := v.(map[string]any)
return ok
}

@ -63,7 +63,7 @@ func TestLoadDependency(t *testing.T) {
}
func TestDependencyEnabled(t *testing.T) {
type M = map[string]interface{}
type M = map[string]any
tests := []struct {
name string
v M

@ -157,7 +157,7 @@ func TestSavePreservesTimestamps(t *testing.T) {
Version: "1.2.3",
},
ModTime: initialCreateTime,
Values: map[string]interface{}{
Values: map[string]any{
"imageName": "testimage",
"imageId": 42,
},

@ -102,7 +102,7 @@ type Writer interface {
// EncodeJSON is a helper function to decorate any error message with a bit more
// context and avoid writing the same code over and over for printers.
func EncodeJSON(out io.Writer, obj interface{}) error {
func EncodeJSON(out io.Writer, obj any) error {
enc := json.NewEncoder(out)
err := enc.Encode(obj)
if err != nil {
@ -113,7 +113,7 @@ func EncodeJSON(out io.Writer, obj interface{}) error {
// EncodeYAML is a helper function to decorate any error message with a bit more
// context and avoid writing the same code over and over for printers
func EncodeYAML(out io.Writer, obj interface{}) error {
func EncodeYAML(out io.Writer, obj any) error {
raw, err := yaml.Marshal(obj)
if err != nil {
return fmt.Errorf("unable to write YAML output: %w", err)

@ -298,7 +298,7 @@ func TestMergeValuesCLI(t *testing.T) {
tests := []struct {
name string
opts Options
expected map[string]interface{}
expected map[string]any
wantErr bool
}{
{
@ -306,8 +306,8 @@ func TestMergeValuesCLI(t *testing.T) {
opts: Options{
JSONValues: []string{`{"foo": {"bar": "baz"}}`},
},
expected: map[string]interface{}{
"foo": map[string]interface{}{
expected: map[string]any{
"foo": map[string]any{
"bar": "baz",
},
},
@ -317,9 +317,9 @@ func TestMergeValuesCLI(t *testing.T) {
opts: Options{
JSONValues: []string{"foo.bar=[1,2,3]"},
},
expected: map[string]interface{}{
"foo": map[string]interface{}{
"bar": []interface{}{1.0, 2.0, 3.0},
expected: map[string]any{
"foo": map[string]any{
"bar": []any{1.0, 2.0, 3.0},
},
},
},
@ -328,7 +328,7 @@ func TestMergeValuesCLI(t *testing.T) {
opts: Options{
Values: []string{"foo=bar"},
},
expected: map[string]interface{}{
expected: map[string]any{
"foo": "bar",
},
},
@ -337,7 +337,7 @@ func TestMergeValuesCLI(t *testing.T) {
opts: Options{
StringValues: []string{"foo=123"},
},
expected: map[string]interface{}{
expected: map[string]any{
"foo": "123",
},
},
@ -346,7 +346,7 @@ func TestMergeValuesCLI(t *testing.T) {
opts: Options{
LiteralValues: []string{"foo=true"},
},
expected: map[string]interface{}{
expected: map[string]any{
"foo": "true",
},
},
@ -358,7 +358,7 @@ func TestMergeValuesCLI(t *testing.T) {
JSONValues: []string{`{"c": "foo1"}`},
LiteralValues: []string{"d=bar1"},
},
expected: map[string]interface{}{
expected: map[string]any{
"a": "foo",
"b": "bar",
"c": "foo1",

@ -20,6 +20,7 @@ import (
"fmt"
"os"
"path/filepath"
"slices"
"testing"
chartv3 "helm.sh/helm/v4/internal/chart/v3"
@ -188,13 +189,7 @@ func TestCreateStarterCmd(t *testing.T) {
}
// Verify custom template exists
found := false
for _, name := range templates {
if name == "templates/foo.tpl" {
found = true
break
}
}
found := slices.Contains(templates, "templates/foo.tpl")
if !found {
t.Error("Did not find foo.tpl")
}

@ -53,7 +53,7 @@ func newGetAllCmd(cfg *action.Configuration, out io.Writer) *cobra.Command {
return err
}
if template != "" {
data := map[string]interface{}{
data := map[string]any{
"Release": res,
}
return tpl(template, data, out)

@ -33,7 +33,7 @@ This command downloads a values file for a given release.
`
type valuesWriter struct {
vals map[string]interface{}
vals map[string]any
allValues bool
}

@ -106,7 +106,7 @@ type releaseInfoJSON struct {
// It handles empty string time fields by treating them as zero values.
func (r *releaseInfo) UnmarshalJSON(data []byte) error {
// First try to unmarshal into a map to handle empty string time fields
var raw map[string]interface{}
var raw map[string]any
if err := json.Unmarshal(data, &raw); err != nil {
return err
}

@ -321,7 +321,7 @@ func TestReleaseInfoEmptyStringRoundTrip(t *testing.T) {
data, err := json.Marshal(&info)
require.NoError(t, err)
var result map[string]interface{}
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)

@ -21,7 +21,7 @@ import (
"text/template"
)
func tpl(t string, vals map[string]interface{}, out io.Writer) error {
func tpl(t string, vals map[string]any, out io.Writer) error {
tt, err := template.New("_").Parse(t)
if err != nil {
return err

@ -129,8 +129,8 @@ func warnWrap(warn string) string {
// 'include' needs to be defined in the scope of a 'tpl' template as
// well as regular file-loaded templates.
func includeFun(t *template.Template, includedNames map[string]int) func(string, interface{}) (string, error) {
return func(name string, data interface{}) (string, error) {
func includeFun(t *template.Template, includedNames map[string]int) func(string, any) (string, error) {
return func(name string, data any) (string, error) {
var buf strings.Builder
if v, ok := includedNames[name]; ok {
if v > recursionMaxNums {
@ -150,8 +150,8 @@ func includeFun(t *template.Template, includedNames map[string]int) func(string,
// As does 'tpl', so that nested calls to 'tpl' see the templates
// defined by their enclosing contexts.
func tplFun(parent *template.Template, includedNames map[string]int, strict bool) func(string, interface{}) (string, error) {
return func(tpl string, vals interface{}) (string, error) {
func tplFun(parent *template.Template, includedNames map[string]int, strict bool) func(string, any) (string, error) {
return func(tpl string, vals any) (string, error) {
t, err := parent.Clone()
if err != nil {
return "", fmt.Errorf("cannot clone template: %w", err)
@ -204,7 +204,7 @@ func (e Engine) initFunMap(t *template.Template) {
funcMap["tpl"] = tplFun(t, includedNames, e.Strict)
// Add the `required` function here so we can use lintMode
funcMap["required"] = func(warn string, val interface{}) (interface{}, error) {
funcMap["required"] = func(warn string, val any) (any, error) {
if val == nil {
if e.LintMode {
// Don't fail on missing required values when linting
@ -410,9 +410,9 @@ func parseTemplateSimpleErrorString(remainder string) (TraceableError, bool) {
// Executing form: "<templateName>: executing \"<funcName>\" at <<location>>: <errMsg>[ template:...]"
// Matches https://cs.opensource.google/go/go/+/refs/tags/go1.23.6:src/text/template/exec.go;l=141
func parseTemplateExecutingAtErrorType(remainder string) (TraceableError, bool) {
if idx := strings.Index(remainder, ": executing "); idx != -1 {
templateName := remainder[:idx]
after := remainder[idx+len(": executing "):]
if before, after, ok := strings.Cut(remainder, ": executing "); ok {
templateName := before
after := after
if len(after) == 0 || after[0] != '"' {
return TraceableError{}, false
}
@ -431,12 +431,12 @@ func parseTemplateExecutingAtErrorType(remainder string) (TraceableError, bool)
return TraceableError{}, false
}
afterAt := afterFunc[len(atPrefix):]
endLoc := strings.Index(afterAt, ">: ")
if endLoc == -1 {
before, after0, ok := strings.Cut(afterAt, ">: ")
if !ok {
return TraceableError{}, false
}
locationName := afterAt[:endLoc]
errMsg := afterAt[endLoc+len(">: "):]
locationName := before
errMsg := after0
// trim chained next error starting with space + "template:" if present
if cut := strings.Index(errMsg, " template:"); cut != -1 {
@ -535,9 +535,9 @@ func allTemplates(c ci.Charter, vals common.Values) map[string]renderable {
//
// As it recurses, it also sets the values to be appropriate for the template
// scope.
func recAllTpls(c ci.Charter, templates map[string]renderable, values common.Values) map[string]interface{} {
func recAllTpls(c ci.Charter, templates map[string]renderable, values common.Values) map[string]any {
vals := values.AsMap()
subCharts := make(map[string]interface{})
subCharts := make(map[string]any)
accessor, err := ci.NewAccessor(c)
if err != nil {
slog.Error("error accessing chart", "error", err)
@ -545,7 +545,7 @@ func recAllTpls(c ci.Charter, templates map[string]renderable, values common.Val
chartMetaData := accessor.MetadataAsMap()
chartMetaData["IsRoot"] = accessor.IsRoot()
next := map[string]interface{}{
next := map[string]any{
"Chart": chartMetaData,
"Files": newFiles(accessor.Files()),
"Release": vals["Release"],

@ -104,14 +104,14 @@ func TestRender(t *testing.T) {
{Name: "templates/test4", ModTime: modTime, Data: []byte("{{toJson .Values}}")},
{Name: "templates/test5", ModTime: modTime, Data: []byte("{{getHostByName \"helm.sh\"}}")},
},
Values: map[string]interface{}{"outer": "DEFAULT", "inner": "DEFAULT"},
Values: map[string]any{"outer": "DEFAULT", "inner": "DEFAULT"},
}
vals := map[string]interface{}{
"Values": map[string]interface{}{
vals := map[string]any{
"Values": map[string]any{
"outer": "spouter",
"inner": "inn",
"global": map[string]interface{}{
"global": map[string]any{
"callme": "Ishmael",
},
},
@ -226,11 +226,11 @@ func TestRenderWithDNS(t *testing.T) {
Templates: []*common.File{
{Name: "templates/test1", ModTime: time.Now(), Data: []byte("{{getHostByName \"helm.sh\"}}")},
},
Values: map[string]interface{}{},
Values: map[string]any{},
}
vals := map[string]interface{}{
"Values": map[string]interface{}{},
vals := map[string]any{
"Values": map[string]any{},
}
v, err := util.CoalesceValues(c, vals)
@ -277,15 +277,15 @@ var _ ClientProvider = &testClientProvider{}
// makeUnstructured is a convenience function for single-line creation of Unstructured objects.
func makeUnstructured(apiVersion, kind, name, namespace string) *unstructured.Unstructured {
ret := &unstructured.Unstructured{Object: map[string]interface{}{
ret := &unstructured.Unstructured{Object: map[string]any{
"apiVersion": apiVersion,
"kind": kind,
"metadata": map[string]interface{}{
"metadata": map[string]any{
"name": name,
},
}}
if namespace != "" {
ret.Object["metadata"].(map[string]interface{})["namespace"] = namespace
ret.Object["metadata"].(map[string]any)["namespace"] = namespace
}
return ret
}
@ -356,7 +356,7 @@ func TestRenderWithClientProvider(t *testing.T) {
Name: "moby",
Version: "1.2.3",
},
Values: map[string]interface{}{},
Values: map[string]any{},
}
modTime := time.Now()
@ -368,8 +368,8 @@ func TestRenderWithClientProvider(t *testing.T) {
})
}
vals := map[string]interface{}{
"Values": map[string]interface{}{},
vals := map[string]any{
"Values": map[string]any{},
}
v, err := util.CoalesceValues(c, vals)
@ -401,11 +401,11 @@ func TestRenderWithClientProvider_error(t *testing.T) {
Templates: []*common.File{
{Name: "templates/error", ModTime: time.Now(), Data: []byte(`{{ lookup "v1" "Error" "" "" }}`)},
},
Values: map[string]interface{}{},
Values: map[string]any{},
}
vals := map[string]interface{}{
"Values": map[string]interface{}{},
vals := map[string]any{
"Values": map[string]any{},
}
v, err := util.CoalesceValues(c, vals)
@ -438,7 +438,7 @@ func TestParallelRenderInternals(t *testing.T) {
tpls := map[string]renderable{
"t": {
tpl: `{{.val}}`,
vals: map[string]interface{}{"val": tt},
vals: map[string]any{"val": tt},
},
}
out, err := e.render(tpls)
@ -455,7 +455,7 @@ func TestParallelRenderInternals(t *testing.T) {
}
func TestParseErrors(t *testing.T) {
vals := common.Values{"Values": map[string]interface{}{}}
vals := common.Values{"Values": map[string]any{}}
tplsUndefinedFunction := map[string]renderable{
"undefined_function": {tpl: `{{foo}}`, vals: vals},
@ -471,7 +471,7 @@ func TestParseErrors(t *testing.T) {
}
func TestExecErrors(t *testing.T) {
vals := common.Values{"Values": map[string]interface{}{}}
vals := common.Values{"Values": map[string]any{}}
cases := []struct {
name string
tpls map[string]renderable
@ -535,7 +535,7 @@ linebreak`,
}
func TestFailErrors(t *testing.T) {
vals := common.Values{"Values": map[string]interface{}{}}
vals := common.Values{"Values": map[string]any{}}
failtpl := `All your base are belong to us{{ fail "This is an error" }}`
tplsFailed := map[string]renderable{
@ -643,7 +643,7 @@ func TestRenderDependency(t *testing.T) {
},
})
out, err := Render(ch, map[string]interface{}{})
out, err := Render(ch, map[string]any{})
if err != nil {
t.Fatalf("failed to render chart: %s", err)
}
@ -675,7 +675,7 @@ func TestRenderNestedValues(t *testing.T) {
{Name: deepestpath, ModTime: modTime, Data: []byte(`And this same {{.Values.what}} that smiles {{.Values.global.when}}`)},
{Name: checkrelease, ModTime: modTime, Data: []byte(`Tomorrow will be {{default "happy" .Release.Name }}`)},
},
Values: map[string]interface{}{"what": "milkshake", "where": "here"},
Values: map[string]any{"what": "milkshake", "where": "here"},
}
inner := &chart.Chart{
@ -683,7 +683,7 @@ func TestRenderNestedValues(t *testing.T) {
Templates: []*common.File{
{Name: innerpath, ModTime: modTime, Data: []byte(`Old {{.Values.who}} is still a-flyin'`)},
},
Values: map[string]interface{}{"who": "Robert", "what": "glasses"},
Values: map[string]any{"who": "Robert", "what": "glasses"},
}
inner.AddDependency(deepest)
@ -693,10 +693,10 @@ func TestRenderNestedValues(t *testing.T) {
{Name: outerpath, ModTime: modTime, Data: []byte(`Gather ye {{.Values.what}} while ye may`)},
{Name: subchartspath, ModTime: modTime, Data: []byte(`The glorious Lamp of {{.Subcharts.herrick.Subcharts.deepest.Values.where}}, the {{.Subcharts.herrick.Values.what}}`)},
},
Values: map[string]interface{}{
Values: map[string]any{
"what": "stinkweed",
"who": "me",
"herrick": map[string]interface{}{
"herrick": map[string]any{
"who": "time",
"what": "Sun",
},
@ -704,15 +704,15 @@ func TestRenderNestedValues(t *testing.T) {
}
outer.AddDependency(inner)
injValues := map[string]interface{}{
injValues := map[string]any{
"what": "rosebuds",
"herrick": map[string]interface{}{
"deepest": map[string]interface{}{
"herrick": map[string]any{
"deepest": map[string]any{
"what": "flower",
"where": "Heaven",
},
},
"global": map[string]interface{}{
"global": map[string]any{
"when": "to-day",
},
}
@ -1349,7 +1349,7 @@ NestedHelperFunctions/charts/common/templates/_helpers_2.tpl:1:49
v := common.Values{}
val, _ := util.CoalesceValues(c, v)
vals := map[string]interface{}{
vals := map[string]any{
"Values": val.AsMap(),
}
_, err := Render(c, vals)
@ -1383,7 +1383,7 @@ template: no template "nested_helper.name" associated with template "gotpl"`
v := common.Values{}
val, _ := util.CoalesceValues(c, v)
vals := map[string]interface{}{
vals := map[string]any{
"Values": val.AsMap(),
}
_, err := Render(c, vals)

@ -64,13 +64,13 @@ func funcMap() template.FuncMap {
// This is a placeholder for the "include" function, which is
// late-bound to a template. By declaring it here, we preserve the
// integrity of the linter.
"include": func(string, interface{}) string { return "not implemented" },
"tpl": func(string, interface{}) interface{} { return "not implemented" },
"required": func(string, interface{}) (interface{}, error) { return "not implemented", nil },
"include": func(string, any) string { return "not implemented" },
"tpl": func(string, any) any { return "not implemented" },
"required": func(string, any) (any, error) { return "not implemented", nil },
// Provide a placeholder for the "lookup" function, which requires a kubernetes
// connection.
"lookup": func(string, string, string, string) (map[string]interface{}, error) {
return map[string]interface{}{}, nil
"lookup": func(string, string, string, string) (map[string]any, error) {
return map[string]any{}, nil
},
}
@ -83,7 +83,7 @@ func funcMap() template.FuncMap {
// always return a string, even on marshal error (empty string).
//
// This is designed to be called from a template.
func toYAML(v interface{}) string {
func toYAML(v any) string {
data, err := yaml.Marshal(v)
if err != nil {
// Swallow errors inside of a template.
@ -97,7 +97,7 @@ func toYAML(v interface{}) string {
//
// This is designed to be called from a template when need to ensure that the
// output YAML is valid.
func mustToYAML(v interface{}) string {
func mustToYAML(v any) string {
data, err := yaml.Marshal(v)
if err != nil {
panic(err)
@ -105,7 +105,7 @@ func mustToYAML(v interface{}) string {
return strings.TrimSuffix(string(data), "\n")
}
func toYAMLPretty(v interface{}) string {
func toYAMLPretty(v any) string {
var data bytes.Buffer
encoder := goYaml.NewEncoder(&data)
encoder.SetIndent(2)
@ -124,8 +124,8 @@ func toYAMLPretty(v interface{}) string {
// YAML documents. Additionally, because its intended use is within templates
// it tolerates errors. It will insert the returned error message string into
// m["Error"] in the returned map.
func fromYAML(str string) map[string]interface{} {
m := map[string]interface{}{}
func fromYAML(str string) map[string]any {
m := map[string]any{}
if err := yaml.Unmarshal([]byte(str), &m); err != nil {
m["Error"] = err.Error()
@ -139,11 +139,11 @@ func fromYAML(str string) map[string]interface{} {
// YAML documents. Additionally, because its intended use is within templates
// it tolerates errors. It will insert the returned error message string as
// the first and only item in the returned array.
func fromYAMLArray(str string) []interface{} {
a := []interface{}{}
func fromYAMLArray(str string) []any {
a := []any{}
if err := yaml.Unmarshal([]byte(str), &a); err != nil {
a = []interface{}{err.Error()}
a = []any{err.Error()}
}
return a
}
@ -152,7 +152,7 @@ func fromYAMLArray(str string) []interface{} {
// always return a string, even on marshal error (empty string).
//
// This is designed to be called from a template.
func toTOML(v interface{}) string {
func toTOML(v any) string {
b := bytes.NewBuffer(nil)
e := toml.NewEncoder(b)
err := e.Encode(v)
@ -168,8 +168,8 @@ func toTOML(v interface{}) string {
// TOML documents. Additionally, because its intended use is within templates
// it tolerates errors. It will insert the returned error message string into
// m["Error"] in the returned map.
func fromTOML(str string) map[string]interface{} {
m := make(map[string]interface{})
func fromTOML(str string) map[string]any {
m := make(map[string]any)
if err := toml.Unmarshal([]byte(str), &m); err != nil {
m["Error"] = err.Error()
@ -181,7 +181,7 @@ func fromTOML(str string) map[string]interface{} {
// always return a string, even on marshal error (empty string).
//
// This is designed to be called from a template.
func toJSON(v interface{}) string {
func toJSON(v any) string {
data, err := json.Marshal(v)
if err != nil {
// Swallow errors inside of a template.
@ -195,7 +195,7 @@ func toJSON(v interface{}) string {
//
// This is designed to be called from a template when need to ensure that the
// output JSON is valid.
func mustToJSON(v interface{}) string {
func mustToJSON(v any) string {
data, err := json.Marshal(v)
if err != nil {
panic(err)
@ -209,8 +209,8 @@ func mustToJSON(v interface{}) string {
// JSON documents. Additionally, because its intended use is within templates
// it tolerates errors. It will insert the returned error message string into
// m["Error"] in the returned map.
func fromJSON(str string) map[string]interface{} {
m := make(map[string]interface{})
func fromJSON(str string) map[string]any {
m := make(map[string]any)
if err := json.Unmarshal([]byte(str), &m); err != nil {
m["Error"] = err.Error()
@ -224,11 +224,11 @@ func fromJSON(str string) map[string]interface{} {
// JSON documents. Additionally, because its intended use is within templates
// it tolerates errors. It will insert the returned error message string as
// the first and only item in the returned array.
func fromJSONArray(str string) []interface{} {
a := []interface{}{}
func fromJSONArray(str string) []any {
a := []any{}
if err := json.Unmarshal([]byte(str), &a); err != nil {
a = []interface{}{err.Error()}
a = []any{err.Error()}
}
return a
}

@ -28,19 +28,19 @@ func TestFuncs(t *testing.T) {
//TODO write tests for failure cases
tests := []struct {
tpl, expect string
vars interface{}
vars any
}{{
tpl: `{{ toYaml . }}`,
expect: `foo: bar`,
vars: map[string]interface{}{"foo": "bar"},
vars: map[string]any{"foo": "bar"},
}, {
tpl: `{{ toYamlPretty . }}`,
expect: "baz:\n - 1\n - 2\n - 3",
vars: map[string]interface{}{"baz": []int{1, 2, 3}},
vars: map[string]any{"baz": []int{1, 2, 3}},
}, {
tpl: `{{ toToml . }}`,
expect: "foo = \"bar\"\n",
vars: map[string]interface{}{"foo": "bar"},
vars: map[string]any{"foo": "bar"},
}, {
tpl: `{{ fromToml . }}`,
expect: "map[hello:world]",
@ -68,7 +68,7 @@ keyInElement1 = "valueInElement1"`,
}, {
tpl: `{{ toJson . }}`,
expect: `{"foo":"bar"}`,
vars: map[string]interface{}{"foo": "bar"},
vars: map[string]any{"foo": "bar"},
}, {
tpl: `{{ fromYaml . }}`,
expect: "map[hello:world]",
@ -109,11 +109,11 @@ keyInElement1 = "valueInElement1"`,
}, {
tpl: `{{ merge .dict (fromYaml .yaml) }}`,
expect: `map[a:map[b:c]]`,
vars: map[string]interface{}{"dict": map[string]interface{}{"a": map[string]interface{}{"b": "c"}}, "yaml": `{"a":{"b":"d"}}`},
vars: map[string]any{"dict": map[string]any{"a": map[string]any{"b": "c"}}, "yaml": `{"a":{"b":"d"}}`},
}, {
tpl: `{{ merge (fromYaml .yaml) .dict }}`,
expect: `map[a:map[b:d]]`,
vars: map[string]interface{}{"dict": map[string]interface{}{"a": map[string]interface{}{"b": "c"}}, "yaml": `{"a":{"b":"d"}}`},
vars: map[string]any{"dict": map[string]any{"a": map[string]any{"b": "c"}}, "yaml": `{"a":{"b":"d"}}`},
}, {
tpl: `{{ fromYaml . }}`,
expect: `map[Error:error unmarshaling JSON: while decoding JSON: json: cannot unmarshal array into Go value of type map[string]interface {}]`,
@ -136,15 +136,15 @@ keyInElement1 = "valueInElement1"`,
assert.Equal(t, tt.expect, b.String(), tt.tpl)
}
loopMap := map[string]interface{}{
loopMap := map[string]any{
"foo": "bar",
}
loopMap["loop"] = []interface{}{loopMap}
loopMap["loop"] = []any{loopMap}
mustFuncsTests := []struct {
tpl string
expect interface{}
vars interface{}
expect any
vars any
}{{
tpl: `{{ mustToYaml . }}`,
vars: loopMap,
@ -186,34 +186,34 @@ keyInElement1 = "valueInElement1"`,
// be used to accidentally update mergo. This test and message should catch
// the problem and explain why it's happening.
func TestMerge(t *testing.T) {
dict := map[string]interface{}{
"src2": map[string]interface{}{
dict := map[string]any{
"src2": map[string]any{
"h": 10,
"i": "i",
"j": "j",
},
"src1": map[string]interface{}{
"src1": map[string]any{
"a": 1,
"b": 2,
"d": map[string]interface{}{
"d": map[string]any{
"e": "four",
},
"g": []int{6, 7},
"i": "aye",
"j": "jay",
"k": map[string]interface{}{
"k": map[string]any{
"l": false,
},
},
"dst": map[string]interface{}{
"dst": map[string]any{
"a": "one",
"c": 3,
"d": map[string]interface{}{
"d": map[string]any{
"f": 5,
},
"g": []int{8, 9},
"i": "eye",
"k": map[string]interface{}{
"k": map[string]any{
"l": true,
},
},
@ -223,11 +223,11 @@ func TestMerge(t *testing.T) {
err := template.Must(template.New("test").Funcs(funcMap()).Parse(tpl)).Execute(&b, dict)
assert.NoError(t, err)
expected := map[string]interface{}{
expected := map[string]any{
"a": "one", // key overridden
"b": 2, // merged from src1
"c": 3, // merged from dst
"d": map[string]interface{}{ // deep merge
"d": map[string]any{ // deep merge
"e": "four",
"f": 5,
},
@ -235,7 +235,7 @@ func TestMerge(t *testing.T) {
"h": 10, // merged from src2
"i": "eye", // overridden twice
"j": "jay", // overridden and merged
"k": map[string]interface{}{
"k": map[string]any{
"l": true, // overridden
},
}

@ -271,7 +271,7 @@ func getRuntimeObjFromManifests(t *testing.T, manifests []string) []runtime.Obje
t.Helper()
objects := []runtime.Object{}
for _, manifest := range manifests {
m := make(map[string]interface{})
m := make(map[string]any)
err := yaml.Unmarshal([]byte(manifest), &m)
assert.NoError(t, err)
resource := &unstructured.Unstructured{Object: m}

@ -39,7 +39,7 @@ import (
func TestSelectorsForObject(t *testing.T) {
tests := []struct {
name string
object interface{}
object any
expectError bool
errorContains string
expectedLabels map[string]string

@ -332,7 +332,7 @@ func parseMessageBlock(data []byte) (*SumCollection, error) {
//
// This is the generic version that can work with any metadata type.
// The metadata parameter should be a pointer to a struct that can be unmarshaled from YAML.
func ParseMessageBlock(data []byte, metadata interface{}, sums *SumCollection) error {
func ParseMessageBlock(data []byte, metadata any, sums *SumCollection) error {
parts := bytes.Split(data, []byte("\n...\n"))
if len(parts) < 2 {
return errors.New("message block must have at least two parts")

@ -137,7 +137,7 @@ func setup(suite *TestRegistry, tlsEnabled, insecure bool) {
config.HTTP.Addr = ln.Addr().String()
config.HTTP.DrainTimeout = time.Duration(10) * time.Second
config.Storage = map[string]configuration.Parameters{"inmemory": map[string]interface{}{}}
config.Storage = map[string]configuration.Parameters{"inmemory": map[string]any{}}
config.Auth = configuration.Auth{
"htpasswd": configuration.Parameters{

@ -22,9 +22,9 @@ import (
"helm.sh/helm/v4/pkg/chart"
)
type Releaser interface{}
type Releaser any
type Hook interface{}
type Hook any
type Accessor interface {
Name() string

@ -86,7 +86,7 @@ type Hook struct {
// Events are the events that this hook fires on.
Events []HookEvent `json:"events,omitempty"`
// LastRun indicates the date/time this was last run.
LastRun HookExecution `json:"last_run,omitempty"`
LastRun HookExecution `json:"last_run"`
// Weight indicates the sort order for execution among similar Hook type
Weight int `json:"weight,omitempty"`
// DeletePolicies are the policies that indicate when to delete the hook
@ -133,7 +133,7 @@ type hookExecutionJSON struct {
// It handles empty string time fields by treating them as zero values.
func (h *HookExecution) UnmarshalJSON(data []byte) error {
// First try to unmarshal into a map to handle empty string time fields
var raw map[string]interface{}
var raw map[string]any
if err := json.Unmarshal(data, &raw); err != nil {
return err
}

@ -220,7 +220,7 @@ func TestHookExecutionEmptyStringRoundTrip(t *testing.T) {
data, err := json.Marshal(&exec)
require.NoError(t, err)
var result map[string]interface{}
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)

@ -57,7 +57,7 @@ type infoJSON struct {
// It handles empty string time fields by treating them as zero values.
func (i *Info) UnmarshalJSON(data []byte) error {
// First try to unmarshal into a map to handle empty string time fields
var raw map[string]interface{}
var raw map[string]any
if err := json.Unmarshal(data, &raw); err != nil {
return err
}

@ -272,7 +272,7 @@ func TestInfoEmptyStringRoundTrip(t *testing.T) {
data, err := json.Marshal(&info)
require.NoError(t, err)
var result map[string]interface{}
var result map[string]any
err = json.Unmarshal(data, &result)
require.NoError(t, err)

@ -123,7 +123,7 @@ func Mock(opts *MockReleaseOptions) *Release {
Name: name,
Info: info,
Chart: ch,
Config: map[string]interface{}{"name": "value"},
Config: map[string]any{"name": "value"},
Version: version,
Namespace: namespace,
Hooks: []*Hook{

@ -36,7 +36,7 @@ type Release struct {
Chart *chart.Chart `json:"chart,omitempty"`
// Config is the set of extra Values added to the chart.
// These values override the default values inside of the chart.
Config map[string]interface{} `json:"config,omitempty"`
Config map[string]any `json:"config,omitempty"`
// Manifest is the string representation of the rendered template.
Manifest string `json:"manifest,omitempty"`
// Hooks are all of the hooks declared for this release.

@ -137,7 +137,7 @@ func sortHooksByKind(hooks []*release.Hook, ordering KindSortOrder) []*release.H
return h
}
func lessByKind(_ interface{}, _ interface{}, kindA string, kindB string, o KindSortOrder) bool {
func lessByKind(_ any, _ any, kindA string, kindB string, o KindSortOrder) bool {
ordering := make(map[string]int, len(o))
for v, k := range o {
ordering[k] = v

@ -80,7 +80,7 @@ func (c ChartVersions) Less(a, b int) bool {
// IndexFile represents the index file in a chart repository
type IndexFile struct {
// This is used ONLY for validation against chartmuseum's index files and is discarded after validation.
ServerInfo map[string]interface{} `json:"serverInfo,omitempty"`
ServerInfo map[string]any `json:"serverInfo,omitempty"`
APIVersion string `json:"apiVersion"`
Generated time.Time `json:"generated"`
Entries map[string]ChartVersions `json:"entries"`
@ -270,7 +270,7 @@ func (i *IndexFile) Merge(f *IndexFile) {
type ChartVersion struct {
*chart.Metadata
URLs []string `json:"urls"`
Created time.Time `json:"created,omitempty"`
Created time.Time `json:"created"`
Removed bool `json:"removed,omitempty"`
Digest string `json:"digest,omitempty"`
@ -391,7 +391,7 @@ func loadIndex(data []byte, source string) (*IndexFile, error) {
// checking its validity as JSON. If the data is valid JSON, it will use the
// `encoding/json` package to unmarshal it. Otherwise, it will use the
// `sigs.k8s.io/yaml` package to unmarshal the YAML data.
func jsonOrYamlUnmarshal(b []byte, i interface{}) error {
func jsonOrYamlUnmarshal(b []byte, i any) error {
if json.Valid(b) {
return json.Unmarshal(b, i)
}

@ -189,7 +189,7 @@ func NewOCIServer(t *testing.T, dir string) (*OCIServer, error) {
port := ln.Addr().(*net.TCPAddr).Port
config.HTTP.Addr = ln.Addr().String()
config.HTTP.DrainTimeout = time.Duration(10) * time.Second
config.Storage = map[string]configuration.Parameters{"inmemory": map[string]interface{}{}}
config.Storage = map[string]configuration.Parameters{"inmemory": map[string]any{}}
config.Auth = configuration.Auth{
"htpasswd": configuration.Parameters{
"realm": "localhost",

@ -576,7 +576,7 @@ func (test ReleaseTestData) ToRelease() *rspb.Release {
}
}
func assertErrNil(eh func(args ...interface{}), err error, message string) {
func assertErrNil(eh func(args ...any), err error, message string) {
if err != nil {
eh(fmt.Sprintf("%s: %q", message, err))
}

@ -26,8 +26,8 @@ import (
// ParseLiteral parses a set line interpreting the value as a literal string.
//
// A set line is of the form name1=value1
func ParseLiteral(s string) (map[string]interface{}, error) {
vals := map[string]interface{}{}
func ParseLiteral(s string) (map[string]any, error) {
vals := map[string]any{}
scanner := bytes.NewBufferString(s)
t := newLiteralParser(scanner, vals)
err := t.parse()
@ -39,7 +39,7 @@ func ParseLiteral(s string) (map[string]interface{}, error) {
//
// If the strval string has a key that exists in dest, it overwrites the
// dest version.
func ParseLiteralInto(s string, dest map[string]interface{}) error {
func ParseLiteralInto(s string, dest map[string]any) error {
scanner := bytes.NewBufferString(s)
t := newLiteralParser(scanner, dest)
return t.parse()
@ -54,10 +54,10 @@ func ParseLiteralInto(s string, dest map[string]interface{}) error {
// where data is the final parsed data from the parses with correct types
type literalParser struct {
sc *bytes.Buffer
data map[string]interface{}
data map[string]any
}
func newLiteralParser(sc *bytes.Buffer, data map[string]interface{}) *literalParser {
func newLiteralParser(sc *bytes.Buffer, data map[string]any) *literalParser {
return &literalParser{sc: sc, data: data}
}
@ -88,7 +88,7 @@ func runesUntilLiteral(in io.RuneReader, stop map[rune]bool) ([]rune, rune, erro
}
}
func (t *literalParser) key(data map[string]interface{}, nestedNameLevel int) (reterr error) {
func (t *literalParser) key(data map[string]any, nestedNameLevel int) (reterr error) {
defer func() {
if r := recover(); r != nil {
reterr = fmt.Errorf("unable to parse key: %s", r)
@ -120,9 +120,9 @@ func (t *literalParser) key(data map[string]interface{}, nestedNameLevel int) (r
}
// first, create or find the target map in the given data
inner := map[string]interface{}{}
inner := map[string]any{}
if _, ok := data[string(key)]; ok {
inner = data[string(key)].(map[string]interface{})
inner = data[string(key)].(map[string]any)
}
// recurse on sub-tree with remaining data
@ -144,9 +144,9 @@ func (t *literalParser) key(data map[string]interface{}, nestedNameLevel int) (r
kk := string(key)
// find or create target list
list := []interface{}{}
list := []any{}
if _, ok := data[kk]; ok {
list = data[kk].([]interface{})
list = data[kk].([]any)
}
// now we need to get the value after the ]
@ -169,7 +169,7 @@ func (t *literalParser) keyIndex() (int, error) {
return strconv.Atoi(string(v))
}
func (t *literalParser) listItem(list []interface{}, i, nestedNameLevel int) ([]interface{}, error) {
func (t *literalParser) listItem(list []any, i, nestedNameLevel int) ([]any, error) {
if i < 0 {
return list, fmt.Errorf("negative %d index not allowed", i)
}
@ -191,14 +191,14 @@ func (t *literalParser) listItem(list []interface{}, i, nestedNameLevel int) ([]
case lastRune == '.':
// we have a nested object. Send to t.key
inner := map[string]interface{}{}
inner := map[string]any{}
if len(list) > i {
var ok bool
inner, ok = list[i].(map[string]interface{})
inner, ok = list[i].(map[string]any)
if !ok {
// We have indices out of order. Initialize empty value.
list[i] = map[string]interface{}{}
inner = list[i].(map[string]interface{})
list[i] = map[string]any{}
inner = list[i].(map[string]any)
}
}
@ -215,12 +215,12 @@ func (t *literalParser) listItem(list []interface{}, i, nestedNameLevel int) ([]
if err != nil {
return list, fmt.Errorf("error parsing index: %w", err)
}
var crtList []interface{}
var crtList []any
if len(list) > i {
// If nested list already exists, take the value of list to next cycle.
existed := list[i]
if existed != nil {
crtList = list[i].([]interface{})
crtList = list[i].([]any)
}
}

@ -52,8 +52,8 @@ func ToYAML(s string) (string, error) {
// Parse parses a set line.
//
// A set line is of the form name1=value1,name2=value2
func Parse(s string) (map[string]interface{}, error) {
vals := map[string]interface{}{}
func Parse(s string) (map[string]any, error) {
vals := map[string]any{}
scanner := bytes.NewBufferString(s)
t := newParser(scanner, vals, false)
err := t.parse()
@ -63,8 +63,8 @@ func Parse(s string) (map[string]interface{}, error) {
// ParseString parses a set line and forces a string value.
//
// A set line is of the form name1=value1,name2=value2
func ParseString(s string) (map[string]interface{}, error) {
vals := map[string]interface{}{}
func ParseString(s string) (map[string]any, error) {
vals := map[string]any{}
scanner := bytes.NewBufferString(s)
t := newParser(scanner, vals, true)
err := t.parse()
@ -75,7 +75,7 @@ func ParseString(s string) (map[string]interface{}, error) {
//
// If the strval string has a key that exists in dest, it overwrites the
// dest version.
func ParseInto(s string, dest map[string]interface{}) error {
func ParseInto(s string, dest map[string]any) error {
scanner := bytes.NewBufferString(s)
t := newParser(scanner, dest, false)
return t.parse()
@ -87,8 +87,8 @@ func ParseInto(s string, dest map[string]interface{}) error {
//
// When the files at path1 and path2 contained "val1" and "val2" respectively, the set line is consumed as
// name1=val1,name2=val2
func ParseFile(s string, reader RunesValueReader) (map[string]interface{}, error) {
vals := map[string]interface{}{}
func ParseFile(s string, reader RunesValueReader) (map[string]any, error) {
vals := map[string]any{}
scanner := bytes.NewBufferString(s)
t := newFileParser(scanner, vals, reader)
err := t.parse()
@ -98,7 +98,7 @@ func ParseFile(s string, reader RunesValueReader) (map[string]interface{}, error
// ParseIntoString parses a strvals line and merges the result into dest.
//
// This method always returns a string as the value.
func ParseIntoString(s string, dest map[string]interface{}) error {
func ParseIntoString(s string, dest map[string]any) error {
scanner := bytes.NewBufferString(s)
t := newParser(scanner, dest, true)
return t.parse()
@ -109,7 +109,7 @@ func ParseIntoString(s string, dest map[string]interface{}) error {
// An empty val is treated as null.
//
// If a key exists in dest, the new value overwrites the dest version.
func ParseJSON(s string, dest map[string]interface{}) error {
func ParseJSON(s string, dest map[string]any) error {
scanner := bytes.NewBufferString(s)
t := newJSONParser(scanner, dest)
return t.parse()
@ -118,7 +118,7 @@ func ParseJSON(s string, dest map[string]interface{}) error {
// ParseIntoFile parses a filevals line and merges the result into dest.
//
// This method always returns a string as the value.
func ParseIntoFile(s string, dest map[string]interface{}, reader RunesValueReader) error {
func ParseIntoFile(s string, dest map[string]any, reader RunesValueReader) error {
scanner := bytes.NewBufferString(s)
t := newFileParser(scanner, dest, reader)
return t.parse()
@ -126,7 +126,7 @@ func ParseIntoFile(s string, dest map[string]interface{}, reader RunesValueReade
// RunesValueReader is a function that takes the given value (a slice of runes)
// and returns the parsed value
type RunesValueReader func([]rune) (interface{}, error)
type RunesValueReader func([]rune) (any, error)
// parser is a simple parser that takes a strvals line and parses it into a
// map representation.
@ -135,23 +135,23 @@ type RunesValueReader func([]rune) (interface{}, error)
// where data is the final parsed data from the parses with correct types
type parser struct {
sc *bytes.Buffer
data map[string]interface{}
data map[string]any
reader RunesValueReader
isjsonval bool
}
func newParser(sc *bytes.Buffer, data map[string]interface{}, stringBool bool) *parser {
stringConverter := func(rs []rune) (interface{}, error) {
func newParser(sc *bytes.Buffer, data map[string]any, stringBool bool) *parser {
stringConverter := func(rs []rune) (any, error) {
return typedVal(rs, stringBool), nil
}
return &parser{sc: sc, data: data, reader: stringConverter}
}
func newJSONParser(sc *bytes.Buffer, data map[string]interface{}) *parser {
func newJSONParser(sc *bytes.Buffer, data map[string]any) *parser {
return &parser{sc: sc, data: data, reader: nil, isjsonval: true}
}
func newFileParser(sc *bytes.Buffer, data map[string]interface{}, reader RunesValueReader) *parser {
func newFileParser(sc *bytes.Buffer, data map[string]any, reader RunesValueReader) *parser {
return &parser{sc: sc, data: data, reader: reader}
}
@ -176,7 +176,7 @@ func runeSet(r []rune) map[rune]bool {
return s
}
func (t *parser) key(data map[string]interface{}, nestedNameLevel int) (reterr error) {
func (t *parser) key(data map[string]any, nestedNameLevel int) (reterr error) {
defer func() {
if r := recover(); r != nil {
reterr = fmt.Errorf("unable to parse key: %s", r)
@ -200,9 +200,9 @@ func (t *parser) key(data map[string]interface{}, nestedNameLevel int) (reterr e
}
kk := string(k)
// Find or create target list
list := []interface{}{}
list := []any{}
if _, ok := data[kk]; ok {
list = data[kk].([]interface{})
list = data[kk].([]any)
}
// Now we need to get the value after the ].
@ -224,7 +224,7 @@ func (t *parser) key(data map[string]interface{}, nestedNameLevel int) (reterr e
// Since Decode has its own buffer that consumes more characters (from underlying t.sc) than the ones actually decoded,
// we invoke Decode on a separate reader built with a copy of what is left in t.sc. After Decode is executed, we
// discard in t.sc the chars of the decoded json value (the number of those characters is returned by InputOffset).
var jsonval interface{}
var jsonval any
dec := json.NewDecoder(strings.NewReader(t.sc.String()))
if err = dec.Decode(&jsonval); err != nil {
return err
@ -270,9 +270,9 @@ func (t *parser) key(data map[string]interface{}, nestedNameLevel int) (reterr e
}
// First, create or find the target map.
inner := map[string]interface{}{}
inner := map[string]any{}
if _, ok := data[string(k)]; ok {
inner = data[string(k)].(map[string]interface{})
inner = data[string(k)].(map[string]any)
}
// Recurse
@ -288,7 +288,7 @@ func (t *parser) key(data map[string]interface{}, nestedNameLevel int) (reterr e
}
}
func set(data map[string]interface{}, key string, val interface{}) {
func set(data map[string]any, key string, val any) {
// If key is empty, don't set it.
if len(key) == 0 {
return
@ -296,7 +296,7 @@ func set(data map[string]interface{}, key string, val interface{}) {
data[key] = val
}
func setIndex(list []interface{}, index int, val interface{}) (l2 []interface{}, err error) {
func setIndex(list []any, index int, val any) (l2 []any, err error) {
// There are possible index values that are out of range on a target system
// causing a panic. This will catch the panic and return an error instead.
// The value of the index that causes a panic varies from system to system.
@ -313,7 +313,7 @@ func setIndex(list []interface{}, index int, val interface{}) (l2 []interface{},
return list, fmt.Errorf("index of %d is greater than maximum supported index of %d", index, MaxIndex)
}
if len(list) <= index {
newlist := make([]interface{}, index+1)
newlist := make([]any, index+1)
copy(newlist, list)
list = newlist
}
@ -333,7 +333,7 @@ func (t *parser) keyIndex() (int, error) {
}
func (t *parser) listItem(list []interface{}, i, nestedNameLevel int) ([]interface{}, error) {
func (t *parser) listItem(list []any, i, nestedNameLevel int) ([]any, error) {
if i < 0 {
return list, fmt.Errorf("negative %d index not allowed", i)
}
@ -357,7 +357,7 @@ func (t *parser) listItem(list []interface{}, i, nestedNameLevel int) ([]interfa
// Since Decode has its own buffer that consumes more characters (from underlying t.sc) than the ones actually decoded,
// we invoke Decode on a separate reader built with a copy of what is left in t.sc. After Decode is executed, we
// discard in t.sc the chars of the decoded json value (the number of those characters is returned by InputOffset).
var jsonval interface{}
var jsonval any
dec := json.NewDecoder(strings.NewReader(t.sc.String()))
if err = dec.Decode(&jsonval); err != nil {
return list, err
@ -397,12 +397,12 @@ func (t *parser) listItem(list []interface{}, i, nestedNameLevel int) ([]interfa
if err != nil {
return list, fmt.Errorf("error parsing index: %w", err)
}
var crtList []interface{}
var crtList []any
if len(list) > i {
// If nested list already exists, take the value of list to next cycle.
existed := list[i]
if existed != nil {
crtList = list[i].([]interface{})
crtList = list[i].([]any)
}
}
// Now we need to get the value after the ].
@ -413,14 +413,14 @@ func (t *parser) listItem(list []interface{}, i, nestedNameLevel int) ([]interfa
return setIndex(list, i, list2)
case last == '.':
// We have a nested object. Send to t.key
inner := map[string]interface{}{}
inner := map[string]any{}
if len(list) > i {
var ok bool
inner, ok = list[i].(map[string]interface{})
inner, ok = list[i].(map[string]any)
if !ok {
// We have indices out of order. Initialize empty value.
list[i] = map[string]interface{}{}
inner = list[i].(map[string]interface{})
list[i] = map[string]any{}
inner = list[i].(map[string]any)
}
}
@ -463,18 +463,18 @@ func (t *parser) val() ([]rune, error) {
return v, err
}
func (t *parser) valList() ([]interface{}, error) {
func (t *parser) valList() ([]any, error) {
r, _, e := t.sc.ReadRune()
if e != nil {
return []interface{}{}, e
return []any{}, e
}
if r != '{' {
t.sc.UnreadRune()
return []interface{}{}, ErrNotList
return []any{}, ErrNotList
}
list := []interface{}{}
list := []any{}
stop := runeSet([]rune{',', '}'})
for {
switch rs, last, err := runesUntil(t.sc, stop); {
@ -526,7 +526,7 @@ func inMap(k rune, m map[rune]bool) bool {
return ok
}
func typedVal(v []rune, st bool) interface{} {
func typedVal(v []rune, st bool) any {
val := string(v)
if st {

Loading…
Cancel
Save