chore(pkg): fix modernize linter

#### Description

fix modernize linter in pkg/engine

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/31796/head
Matthieu MOREL 3 weeks ago
parent fbb8de54be
commit 0d75d8611d

@ -134,7 +134,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 {
@ -240,13 +240,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",
},
}
@ -280,7 +280,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")
@ -292,7 +292,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)
@ -323,7 +323,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)
@ -346,7 +346,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)
@ -369,7 +369,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)
@ -395,7 +395,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)
@ -423,7 +423,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)
@ -438,7 +438,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)
@ -454,7 +454,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")
@ -466,7 +466,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{
@ -489,7 +489,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>:
@ -507,7 +507,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)
@ -528,7 +528,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)
@ -548,7 +548,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)
@ -568,13 +568,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.")
@ -588,7 +588,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()
@ -609,7 +609,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)
@ -633,7 +633,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)
@ -656,7 +656,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)
@ -679,7 +679,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)
@ -697,7 +697,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)
@ -793,7 +793,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()
@ -825,7 +825,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()
@ -1201,7 +1201,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)

@ -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)

@ -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
},
}

@ -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