this repo has no description
mod: remove unused parameters from APIs
Mostly unnecessary context parameters, including from the exposed
API GetModuleWithManifest, as it is still experimental
and is documented as not fetching anything via an OCI client.
While here, remove unnecessary type parameters as well.
Signed-off-by: Daniel Martí <mvdan@mvdan.cc>
Change-Id: Ie1cd36b856bdae74a2fdba3d738de7305112b7d6
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1195719
TryBot-Result: CUEcueckoo <cueckoo@cuelang.org>
Unity-Result: CUE porcuepine <cue.porcuepine@gmail.com>
Reviewed-by: Paul Jolly <paul@myitcv.io>
+31
-32
+2
-2
internal/mod/modload/tidy.go
+2
-2
internal/mod/modload/tidy.go
···
58
58
}
59
59
60
60
func tidy(ctx context.Context, fsys fs.FS, modRoot string, reg Registry, checkTidy bool) (*modfile.File, error) {
61
-
mainModuleVersion, mf, err := readModuleFile(ctx, fsys, modRoot)
61
+
mainModuleVersion, mf, err := readModuleFile(fsys, modRoot)
62
62
if err != nil {
63
63
return nil, err
64
64
}
···
130
130
maps.Equal(rs0.DefaultMajorVersions(), rs1.DefaultMajorVersions())
131
131
}
132
132
133
-
func readModuleFile(ctx context.Context, fsys fs.FS, modRoot string) (module.Version, *modfile.File, error) {
133
+
func readModuleFile(fsys fs.FS, modRoot string) (module.Version, *modfile.File, error) {
134
134
modFilePath := path.Join(modRoot, "cue.mod/module.cue")
135
135
data, err := fs.ReadFile(fsys, modFilePath)
136
136
if err != nil {
+2
-2
internal/mod/modload/tidy_test.go
+2
-2
internal/mod/modload/tidy_test.go
···
31
31
ar, err := txtar.ParseFile(f)
32
32
qt.Assert(t, qt.IsNil(err))
33
33
tfs := txtarfs.FS(ar)
34
-
reg := newRegistry(t, tfs, "_registry")
34
+
reg := newRegistry(t, tfs)
35
35
36
36
want, err := fs.ReadFile(tfs, "want")
37
37
qt.Assert(t, qt.IsNil(err))
···
80
80
return strings.TrimSpace(string(data))
81
81
}
82
82
83
-
func newRegistry(t *testing.T, fsys fs.FS, root string) Registry {
83
+
func newRegistry(t *testing.T, fsys fs.FS) Registry {
84
84
fsys, err := fs.Sub(fsys, "_registry")
85
85
qt.Assert(t, qt.IsNil(err))
86
86
regSrv, err := registrytest.New(fsys, "")
+1
-1
internal/mod/modload/update.go
+1
-1
internal/mod/modload/update.go
···
29
29
// version or $module@$majorVersion if it does, where $majorVersion is the
30
30
// default major version for $module.
31
31
func UpdateVersions(ctx context.Context, fsys fs.FS, modRoot string, reg Registry, versions []string) (*modfile.File, error) {
32
-
mainModuleVersion, mf, err := readModuleFile(ctx, fsys, modRoot)
32
+
mainModuleVersion, mf, err := readModuleFile(fsys, modRoot)
33
33
if err != nil {
34
34
return nil, err
35
35
}
+1
-1
internal/mod/modload/update_test.go
+1
-1
internal/mod/modload/update_test.go
+7
-7
internal/mod/modpkgload/pkgload.go
+7
-7
internal/mod/modpkgload/pkgload.go
···
223
223
pkg := &Package{
224
224
path: pkgPath,
225
225
}
226
-
pkgs.applyPkgFlags(ctx, pkg, flags)
226
+
pkgs.applyPkgFlags(pkg, flags)
227
227
228
228
pkgs.work.Add(func() { pkgs.load(ctx, pkg) })
229
229
return pkg
230
230
})
231
231
232
232
// Ensure the flags apply even if the package already existed.
233
-
pkgs.applyPkgFlags(ctx, pkg, flags)
233
+
pkgs.applyPkgFlags(pkg, flags)
234
234
return pkg
235
235
}
236
236
···
245
245
return
246
246
}
247
247
if pkgs.mainModuleVersion.Path() == pkg.mod.Path() {
248
-
pkgs.applyPkgFlags(ctx, pkg, PkgInAll)
248
+
pkgs.applyPkgFlags(pkg, PkgInAll)
249
249
}
250
250
pkgQual := module.ParseImportPath(pkg.path).Qualifier
251
251
if pkgQual == "" {
···
292
292
for _, path := range imports {
293
293
pkg.imports = append(pkg.imports, pkgs.addPkg(ctx, path, importFlags))
294
294
}
295
-
pkgs.applyPkgFlags(ctx, pkg, PkgImportsLoaded)
295
+
pkgs.applyPkgFlags(pkg, PkgImportsLoaded)
296
296
}
297
297
298
298
// applyPkgFlags updates pkg.flags to set the given flags and propagate the
299
299
// (transitive) effects of those flags, possibly loading or enqueueing further
300
300
// packages as a result.
301
-
func (pkgs *Packages) applyPkgFlags(ctx context.Context, pkg *Package, flags Flags) {
301
+
func (pkgs *Packages) applyPkgFlags(pkg *Package, flags Flags) {
302
302
if flags == 0 {
303
303
return
304
304
}
···
324
324
// We have just marked pkg with pkgInAll, or we have just loaded its
325
325
// imports, or both. Now is the time to propagate pkgInAll to the imports.
326
326
for _, dep := range pkg.imports {
327
-
pkgs.applyPkgFlags(ctx, dep, PkgInAll)
327
+
pkgs.applyPkgFlags(dep, PkgInAll)
328
328
}
329
329
}
330
330
331
331
if new.has(PkgFromRoot) && !old.has(PkgFromRoot|PkgImportsLoaded) {
332
332
for _, dep := range pkg.imports {
333
-
pkgs.applyPkgFlags(ctx, dep, PkgFromRoot)
333
+
pkgs.applyPkgFlags(dep, PkgFromRoot)
334
334
}
335
335
}
336
336
}
+4
-4
internal/mod/mvs/mvs.go
+4
-4
internal/mod/mvs/mvs.go
···
317
317
}
318
318
}
319
319
320
-
return buildList[V]([]V{target}, &override[V]{target, list, reqs}, func(m V) (V, error) {
320
+
return buildList([]V{target}, &override[V]{target, list, reqs}, func(m V) (V, error) {
321
321
if v, ok := upgradeTo[reqs.Path(m)]; ok {
322
322
return reqs.New(reqs.Path(m), v)
323
323
}
···
340
340
//
341
341
// In order to generate those new requirements, we need to identify versions
342
342
// for every module in the build list — not just reqs.Required(target).
343
-
list, err := BuildList[V]([]V{target}, reqs)
343
+
list, err := BuildList([]V{target}, reqs)
344
344
if err != nil {
345
345
return nil, err
346
346
}
···
460
460
// list with the actual versions of the downgraded modules as selected by MVS,
461
461
// instead of our initial downgrades.
462
462
// (See the downhiddenartifact and downhiddencross test cases).
463
-
actual, err := BuildList[V]([]V{target}, &override[V]{
463
+
actual, err := BuildList([]V{target}, &override[V]{
464
464
target: target,
465
465
list: downgraded,
466
466
Reqs: reqs,
···
485
485
}
486
486
}
487
487
488
-
return BuildList[V]([]V{target}, &override[V]{
488
+
return BuildList([]V{target}, &override[V]{
489
489
target: target,
490
490
list: downgraded,
491
491
Reqs: reqs,
+7
-7
internal/mod/mvs/mvs_test.go
+7
-7
internal/mod/mvs/mvs_test.go
···
505
505
t.Fatalf("build takes one argument: %q", line)
506
506
}
507
507
fns = append(fns, func(t *testing.T) {
508
-
list, err := BuildList[version]([]version{m(kf[1])}, reqs)
508
+
list, err := BuildList([]version{m(kf[1])}, reqs)
509
509
checkList(t, key, list, err, val)
510
510
})
511
511
continue
···
514
514
t.Fatalf("upgrade* takes one argument: %q", line)
515
515
}
516
516
fns = append(fns, func(t *testing.T) {
517
-
list, err := UpgradeAll[version](m(kf[1]), reqs)
517
+
list, err := UpgradeAll(m(kf[1]), reqs)
518
518
checkList(t, key, list, err, val)
519
519
})
520
520
continue
···
523
523
t.Fatalf("upgrade takes at least one argument: %q", line)
524
524
}
525
525
fns = append(fns, func(t *testing.T) {
526
-
list, err := Upgrade[version](m(kf[1]), reqs, ms(kf[2:])...)
526
+
list, err := Upgrade(m(kf[1]), reqs, ms(kf[2:])...)
527
527
if err == nil {
528
528
// Copy the reqs map, but substitute the upgraded requirements in
529
529
// place of the target's original requirements.
···
533
533
}
534
534
upReqs[m(kf[1])] = list
535
535
536
-
list, err = Req[version](m(kf[1]), nil, upReqs)
536
+
list, err = Req(m(kf[1]), nil, upReqs)
537
537
}
538
538
checkList(t, key, list, err, val)
539
539
})
···
543
543
t.Fatalf("upgrade takes at least one argument: %q", line)
544
544
}
545
545
fns = append(fns, func(t *testing.T) {
546
-
list, err := Upgrade[version](m(kf[1]), reqs, ms(kf[2:])...)
546
+
list, err := Upgrade(m(kf[1]), reqs, ms(kf[2:])...)
547
547
checkList(t, key, list, err, val)
548
548
})
549
549
continue
···
552
552
t.Fatalf("downgrade takes at least one argument: %q", line)
553
553
}
554
554
fns = append(fns, func(t *testing.T) {
555
-
list, err := Downgrade[version](m(kf[1]), reqs, ms(kf[1:])...)
555
+
list, err := Downgrade(m(kf[1]), reqs, ms(kf[1:])...)
556
556
checkList(t, key, list, err, val)
557
557
})
558
558
continue
···
561
561
t.Fatalf("req takes at least one argument: %q", line)
562
562
}
563
563
fns = append(fns, func(t *testing.T) {
564
-
list, err := Req[version](m(kf[1]), kf[2:], reqs)
564
+
list, err := Req(m(kf[1]), kf[2:], reqs)
565
565
checkList(t, key, list, err, val)
566
566
})
567
567
continue
+5
-6
mod/modregistry/client.go
+5
-6
mod/modregistry/client.go
···
129
129
return nil, err
130
130
}
131
131
132
-
return c.GetModuleWithManifest(ctx, m, data, rd.Descriptor().MediaType)
132
+
return c.GetModuleWithManifest(m, data, rd.Descriptor().MediaType)
133
133
}
134
134
135
135
// GetModuleWithManifest returns a module instance given
136
136
// the top level manifest contents, without querying its tag.
137
-
// It assumes that the module will be tagged with the given
138
-
// version.
139
-
func (c *Client) GetModuleWithManifest(ctx context.Context, m module.Version, contents []byte, mediaType string) (*Module, error) {
137
+
// It assumes that the module will be tagged with the given version.
138
+
func (c *Client) GetModuleWithManifest(m module.Version, contents []byte, mediaType string) (*Module, error) {
140
139
loc, err := c.resolve(m)
141
140
if err != nil {
142
141
// Note: don't return [ErrNotFound] here because if we've got the
···
146
145
return nil, err
147
146
}
148
147
149
-
manifest, err := unmarshalManifest(ctx, contents, mediaType)
148
+
manifest, err := unmarshalManifest(contents, mediaType)
150
149
if err != nil {
151
150
return nil, fmt.Errorf("module %v: %v", m, err)
152
151
}
···
429
428
return loc, nil
430
429
}
431
430
432
-
func unmarshalManifest(ctx context.Context, data []byte, mediaType string) (*ociregistry.Manifest, error) {
431
+
func unmarshalManifest(data []byte, mediaType string) (*ociregistry.Manifest, error) {
433
432
if !isJSON(mediaType) {
434
433
return nil, fmt.Errorf("expected JSON media type but %q does not look like JSON", mediaType)
435
434
}
+2
-2
mod/modregistry/client_test.go
+2
-2
mod/modregistry/client_test.go
···
254
254
err = reg.DeleteTag(ctx, "foo.com/bar", "v0.5.100")
255
255
qt.Assert(t, qt.IsNil(err))
256
256
257
-
m, err := c.GetModuleWithManifest(ctx, mv, mdata, "application/json")
257
+
m, err := c.GetModuleWithManifest(mv, mdata, "application/json")
258
258
qt.Assert(t, qt.IsNil(err))
259
259
260
260
r, err := m.GetZip(ctx)
···
364
364
func createZip(t *testing.T, mv module.Version, txtarData string) []byte {
365
365
ar := txtar.Parse([]byte(txtarData))
366
366
var zipContent bytes.Buffer
367
-
err := modzip.Create[txtar.File](&zipContent, mv, ar.Files, txtarFileIO{})
367
+
err := modzip.Create(&zipContent, mv, ar.Files, txtarFileIO{})
368
368
qt.Assert(t, qt.IsNil(err))
369
369
return zipContent.Bytes()
370
370
}