internal: add Legacy prefix to GetPsuedoVersions and GetTaggedVersion…

…s functions

The GetPsuedoVersions* and GetTaggedVersions* functions read from the
packages table, and will be replaced by a single GetVersionsForPath
function.

These functions are now prefixed with "Legacy" to indicate that they
will be deprecated.

For golang/go#39629

Change-Id: I7f89f9890f135b5ddb363a51a9706e48d02594b5
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/241899
Reviewed-by: Jonathan Amsterdam <[email protected]>

internal/datasource.go

@@ -26,19 +26,6 @@ type DataSource interface {
  GetModuleInfo(ctx context.Context, modulePath, version string) (*ModuleInfo, error)
  // GetPathInfo returns information about a path.
  GetPathInfo(ctx context.Context, path, inModulePath, inVersion string) (outModulePath, outVersion string, isPackage bool, err error)
- // GetPseudoVersionsForModule returns LegacyModuleInfo for all known
- // pseudo-versions for the module corresponding to modulePath.
- GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
- // GetPseudoVersionsForModule returns LegacyModuleInfo for all known
- // pseudo-versions for any module containing a package with the given import
- // path.
- GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
- // GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
- // versions for the module corresponding to modulePath.
- GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
- // GetTaggedVersionsForModule returns LegacyModuleInfo for all known tagged
- // versions for any module containing a package with the given import path.
- GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 
  // TODO(golang/go#39629): Deprecate these methods.
  //
@@ -47,20 +34,33 @@ type DataSource interface {
  // package paths satisfy this query, it should prefer the module with
  // the longest path.
  LegacyGetDirectory(ctx context.Context, dirPath, modulePath, version string, fields FieldSet) (_ *LegacyDirectory, err error)
+ // LegacyGetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
+ // version.
+ LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
  // LegacyGetModuleLicenses returns all top-level Licenses for the given modulePath
  // and version. (i.e., Licenses contained in the module root directory)
  LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) ([]*licenses.License, error)
  // LegacyGetPackage returns the LegacyVersionedPackage corresponding to the given package
  // pkgPath, modulePath, and version. When multiple package paths satisfy this query, it
  // should prefer the module with the longest path.
  LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (*LegacyVersionedPackage, error)
+ // LegacyGetPackagesInModule returns LegacyPackages contained in the module version
+ // specified by modulePath and version.
+ LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) ([]*LegacyPackage, error)
  // LegacyGetPackageLicenses returns all Licenses that apply to pkgPath, within the
  // module version specified by modulePath and version.
  LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) ([]*licenses.License, error)
- // GetPackagesInModule returns LegacyPackages contained in the module version
- // specified by modulePath and version.
- LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) ([]*LegacyPackage, error)
- // LegacyGetModuleInfo returns the LegacyModuleInfo corresponding to modulePath and
- // version.
- LegacyGetModuleInfo(ctx context.Context, modulePath, version string) (*LegacyModuleInfo, error)
+ // LegacyGetPsuedoVersionsForModule returns ModuleInfo for all known
+ // pseudo-versions for the module corresponding to modulePath.
+ LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
+ // LegacyGetPsuedoVersionsForModule returns ModuleInfo for all known
+ // pseudo-versions for any module containing a package with the given import
+ // path.
+ LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
+ // LegacyGetTaggedVersionsForModule returns ModuleInfo for all known tagged
+ // versions for the module corresponding to modulePath.
+ LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*ModuleInfo, error)
+ // LegacyGetTaggedVersionsForModule returns ModuleInfo for all known tagged
+ // versions for any module containing a package with the given import path.
+ LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*ModuleInfo, error)
 }

internal/frontend/versions.go

@@ -64,14 +64,14 @@ type VersionSummary struct {
 // fetchModuleVersionsDetails builds a version hierarchy for module versions
 // with the same series path as the given version.
 func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi *internal.ModuleInfo) (*VersionsDetails, error) {
- versions, err := ds.GetTaggedVersionsForModule(ctx, mi.ModulePath)
+ versions, err := ds.LegacyGetTaggedVersionsForModule(ctx, mi.ModulePath)
  if err != nil {
  return nil, err
  }
  // If no tagged versions of the module are found, fetch pseudo-versions
  // instead.
  if len(versions) == 0 {
- versions, err = ds.GetPseudoVersionsForModule(ctx, mi.ModulePath)
+ versions, err = ds.LegacyGetPsuedoVersionsForModule(ctx, mi.ModulePath)
  if err != nil {
  return nil, err
  }
@@ -85,14 +85,14 @@ func fetchModuleVersionsDetails(ctx context.Context, ds internal.DataSource, mi
 // fetchPackageVersionsDetails builds a version hierarchy for all module
 // versions containing a package path with v1 import path matching the given v1 path.
 func fetchPackageVersionsDetails(ctx context.Context, ds internal.DataSource, pkgPath, v1Path, modulePath string) (*VersionsDetails, error) {
- versions, err := ds.GetTaggedVersionsForPackageSeries(ctx, pkgPath)
+ versions, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, pkgPath)
  if err != nil {
  return nil, err
  }
  // If no tagged versions for the package series are found, fetch the
  // pseudo-versions instead.
  if len(versions) == 0 {
- versions, err = ds.GetPseudoVersionsForPackageSeries(ctx, pkgPath)
+ versions, err = ds.LegacyGetPsuedoVersionsForPackageSeries(ctx, pkgPath)
  if err != nil {
  return nil, err
  }

internal/postgres/details.go

@@ -74,17 +74,17 @@ func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, version
  return packages, nil
 }
 
-// GetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
+// LegacyGetTaggedVersionsForPackageSeries returns a list of tagged versions sorted in
 // descending semver order. This list includes tagged versions of packages that
 // have the same v1path.
-func (db *DB) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
  return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
-// GetPseudoVersionsForPackageSeries returns the 10 most recent from a list of
+// LegacyGetPsuedoVersionsForPackageSeries returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order. This list includes
 // pseudo-versions of packages that have the same v1path.
-func (db *DB) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) ([]*internal.ModuleInfo, error) {
  return getPackageVersions(ctx, db, pkgPath, []version.Type{version.TypePseudo})
 }
 
@@ -156,15 +156,15 @@ func versionTypeExpr(vts []version.Type) string {
  return strings.Join(vs, ", ")
 }
 
-// GetTaggedVersionsForModule returns a list of tagged versions sorted in
+// LegacyGetTaggedVersionsForModule returns a list of tagged versions sorted in
 // descending semver order.
-func (db *DB) GetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
  return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypeRelease, version.TypePrerelease})
 }
 
-// GetPseudoVersionsForModule returns the 10 most recent from a list of
+// LegacyGetPsuedoVersionsForModule returns the 10 most recent from a list of
 // pseudo-versions sorted in descending semver order.
-func (db *DB) GetPseudoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
+func (db *DB) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) ([]*internal.ModuleInfo, error) {
  return getModuleVersions(ctx, db, modulePath, []version.Type{version.TypePseudo})
 }
 

internal/postgres/details_test.go

@@ -340,7 +340,7 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
  t.Fatal(err)
  }
 
- // GetPseudoVersions should only return the 10 most recent pseudo versions,
+ // LegacyGetPsuedoVersions should only return the 10 most recent pseudo versions,
  // if there are more than 10 in the database
  if i < 10 {
  wantPseudoVersions = append(wantPseudoVersions, &internal.ModuleInfo{
@@ -357,36 +357,36 @@ func TestPostgres_GetTaggedAndPseudoVersions(t *testing.T) {
  }
  }
 
- got, err := testDB.GetPseudoVersionsForPackageSeries(ctx, tc.path)
+ got, err := testDB.LegacyGetPsuedoVersionsForPackageSeries(ctx, tc.path)
  if err != nil {
  t.Fatal(err)
  }
  if diff := cmp.Diff(wantPseudoVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetPseudoVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
+ t.Errorf("testDB.LegacyGetPsuedoVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
  }
 
- got, err = testDB.GetTaggedVersionsForPackageSeries(ctx, tc.path)
+ got, err = testDB.LegacyGetTaggedVersionsForPackageSeries(ctx, tc.path)
  if err != nil {
  t.Fatal(err)
  }
  if diff := cmp.Diff(tc.wantTaggedVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetTaggedVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
+ t.Errorf("testDB.LegacyGetTaggedVersionsForPackageSeries(%q) mismatch (-want +got):\n%s", tc.path, diff)
  }
 
- got, err = testDB.GetPseudoVersionsForModule(ctx, tc.modulePath)
+ got, err = testDB.LegacyGetPsuedoVersionsForModule(ctx, tc.modulePath)
  if err != nil {
  t.Fatal(err)
  }
  if diff := cmp.Diff(wantPseudoVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetPseudoVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
+ t.Errorf("testDB.LegacyGetPsuedoVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
  }
 
- got, err = testDB.GetTaggedVersionsForModule(ctx, tc.modulePath)
+ got, err = testDB.LegacyGetTaggedVersionsForModule(ctx, tc.modulePath)
  if err != nil {
  t.Fatal(err)
  }
  if diff := cmp.Diff(tc.wantTaggedVersions, got, cmp.AllowUnexported(source.Info{})); diff != "" {
- t.Errorf("testDB.GetTaggedVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
+ t.Errorf("testDB.LegacyGetTaggedVersionsForModule(%q) mismatch (-want +got):\n%s", tc.path, diff)
  }
  })
  }

internal/proxydatasource/datasource.go

@@ -189,33 +189,33 @@ func (ds *DataSource) LegacyGetPackagesInModule(ctx context.Context, modulePath,
  return v.LegacyPackages, nil
 }
 
-// GetPseudoVersionsForModule returns versions from the the proxy /list
+// LegacyGetPsuedoVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "GetPseudoVersionsForModule(%q)", modulePath)
+func (ds *DataSource) LegacyGetPsuedoVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
+ defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForModule(%q)", modulePath)
  return ds.listModuleVersions(ctx, modulePath, true)
 }
 
-// GetPseudoVersionsForPackageSeries finds the longest module path containing
+// LegacyGetPsuedoVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // pseudoversions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetPseudoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "GetPseudoVersionsForPackageSeries(%q)", pkgPath)
+func (ds *DataSource) LegacyGetPsuedoVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
+ defer derrors.Wrap(&err, "LegacyGetPsuedoVersionsForPackageSeries(%q)", pkgPath)
  return ds.listPackageVersions(ctx, pkgPath, true)
 }
 
-// GetTaggedVersionsForModule returns versions from the the proxy /list
+// LegacyGetTaggedVersionsForModule returns versions from the the proxy /list
 // endpoint, if they are tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "GetTaggedVersionsForModule(%q)", modulePath)
+func (ds *DataSource) LegacyGetTaggedVersionsForModule(ctx context.Context, modulePath string) (_ []*internal.ModuleInfo, err error) {
+ defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForModule(%q)", modulePath)
  return ds.listModuleVersions(ctx, modulePath, false)
 }
 
-// GetTaggedVersionsForPackageSeries finds the longest module path containing
+// LegacyGetTaggedVersionsForPackageSeries finds the longest module path containing
 // pkgPath, and returns its versions from the proxy /list endpoint, if they are
 // tagged versions. Otherwise, it returns an empty slice.
-func (ds *DataSource) GetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
- defer derrors.Wrap(&err, "GetTaggedVersionsForPackageSeries(%q)", pkgPath)
+func (ds *DataSource) LegacyGetTaggedVersionsForPackageSeries(ctx context.Context, pkgPath string) (_ []*internal.ModuleInfo, err error) {
+ defer derrors.Wrap(&err, "LegacyGetTaggedVersionsForPackageSeries(%q)", pkgPath)
  return ds.listPackageVersions(ctx, pkgPath, false)
 }
 

internal/proxydatasource/datasource_test.go

@@ -195,10 +195,10 @@ func TestDataSource_GetPackagesInVersion(t *testing.T) {
  }
 }
 
-func TestDataSource_GetTaggedVersionsForModule(t *testing.T) {
+func TestDataSource_LegacyGetTaggedVersionsForModule(t *testing.T) {
  ctx, ds, teardown := setup(t)
  defer teardown()
- got, err := ds.GetTaggedVersionsForModule(ctx, "foo.com/bar")
+ got, err := ds.LegacyGetTaggedVersionsForModule(ctx, "foo.com/bar")
  if err != nil {
  t.Fatal(err)
  }
@@ -210,19 +210,19 @@ func TestDataSource_GetTaggedVersionsForModule(t *testing.T) {
  }
  ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
  if diff := cmp.Diff(want, got, ignore); diff != "" {
- t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
+ t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
  }
 }
 
-func TestDataSource_GetTaggedVersionsForPackageSeries(t *testing.T) {
+func TestDataSource_LegacyGetTaggedVersionsForPackageSeries(t *testing.T) {
  ctx, ds, teardown := setup(t)
  defer teardown()
  // // TODO (rFindley): this shouldn't be necessary.
  // _, err := ds.GetLatestPackage(ctx, "foo.com/bar/baz")
  // if err != nil {
  // t.Fatal(err)
  // }
- got, err := ds.GetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
+ got, err := ds.LegacyGetTaggedVersionsForPackageSeries(ctx, "foo.com/bar/baz")
  if err != nil {
  t.Fatal(err)
  }
@@ -234,7 +234,7 @@ func TestDataSource_GetTaggedVersionsForPackageSeries(t *testing.T) {
  }
  ignore := cmpopts.IgnoreFields(internal.ModuleInfo{}, "CommitTime", "VersionType", "IsRedistributable", "HasGoMod")
  if diff := cmp.Diff(want, got, ignore); diff != "" {
- t.Errorf("GetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
+ t.Errorf("LegacyGetTaggedVersionsForPackageSeries diff (-want +got):\n%s", diff)
  }
 }